@tks/wayfinder 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Takeshi Ohishi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,48 @@
+# wayfinder
+
+CLI for one way flight search with SerpApi Google Flights.
+
+## Install
+
+```bash
+bun install
+bun link
+```
+
+`bun link` makes the `wayfinder` command available in your shell.
+
+## Setup
+
+Set API key by environment variable (preferred):
+
+```bash
+export SERPAPI_API_KEY="your_key"
+```
+
+Or store it in `~/.config/wayfinder/config.json`:
+
+```json
+{
+  "serpApiKey": "your_key"
+}
+```
+
+## Usage examples
+
+Search one way flights:
+
+```bash
+wayfinder --from SFO --to JFK --date 2026-04-10
+```
+
+Search with filters:
+
+```bash
+wayfinder --from LAX --to SEA --date 2026-04-10 --airline AS --max-stops 0 --max-price 250 --depart-after 06:00 --depart-before 12:00
+```
+
+Structured output for scripting:
+
+```bash
+wayfinder --from SFO --to JFK --date 2026-04-10 --json | jq '.results[] | {price,airline,stops}'
+```

package/bin/wayfinder

@@ -0,0 +1,5 @@
+#!/usr/bin/env bun
+import { runWayfinder } from "../src/cli.ts";
+
+const code = await runWayfinder(process.argv.slice(2));
+process.exitCode = code;

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@tks/wayfinder",
+  "version": "0.1.0",
+  "license": "MIT",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "wayfinder": "./bin/wayfinder"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "package.json"
+  ],
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "wayfinder": "bun run src/cli.ts",
+    "test": "bun test"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,95 @@
+import { resolveApiKey } from "./config";
+import { CliError } from "./errors";
+import { renderTable } from "./format";
+import { parseCliArgs } from "./parse";
+import { searchFlights } from "./serpapi";
+import { ExitCode } from "./types";
+
+interface Output {
+  stdout: (message: string) => void;
+  stderr: (message: string) => void;
+}
+
+interface RunOptions {
+  env?: NodeJS.ProcessEnv;
+  homeDir?: string;
+  fetchImpl?: typeof fetch;
+  output?: Output;
+}
+
+const HELP_TEXT = `wayfinder v1 flight search
+
+Usage:
+  wayfinder --from SFO --to JFK --date 2026-03-21 [filters]
+  wayfinder flights one-way --from SFO --to JFK --date 2026-03-21 [filters]
+
+Required:
+  --from <IATA>             Origin airport code
+  --to <IATA>               Destination airport code
+  --date <YYYY-MM-DD>       Departure date
+
+Optional filters:
+  --airline <IATA>          Airline code, example UA
+  --max-stops <0|1|2>       Maximum number of stops
+  --max-price <USD>         Max price in USD
+  --depart-after <HH:MM>    Start of departure window
+  --depart-before <HH:MM>   End of departure window
+
+Output:
+  --json                    Print structured JSON output`;
+
+export async function runWayfinder(
+  argv: string[] = process.argv.slice(2),
+  options: RunOptions = {},
+): Promise<number> {
+  const output = options.output ?? {
+    stdout: (message: string) => console.log(message),
+    stderr: (message: string) => console.error(message),
+  };
+
+  try {
+    const parsed = parseCliArgs(argv);
+
+    if (parsed.help) {
+      output.stdout(HELP_TEXT);
+      return ExitCode.Success;
+    }
+
+    const apiKey = resolveApiKey(options.env ?? process.env, options.homeDir);
+    const flights = await searchFlights(parsed.query!, apiKey, options.fetchImpl ?? fetch);
+
+    if (flights.length === 0) {
+      throw new CliError("No flights found for the selected query", ExitCode.NoResults);
+    }
+
+    if (parsed.outputJson) {
+      output.stdout(
+        JSON.stringify(
+          {
+            query: parsed.query,
+            results: flights,
+          },
+          null,
+          2,
+        ),
+      );
+    } else {
+      output.stdout(renderTable(flights));
+    }
+
+    return ExitCode.Success;
+  } catch (error) {
+    if (error instanceof CliError) {
+      output.stderr(error.message);
+      return error.exitCode;
+    }
+
+    output.stderr("Unexpected internal error");
+    return ExitCode.InternalError;
+  }
+}
+
+if (import.meta.main) {
+  const code = await runWayfinder(process.argv.slice(2));
+  process.exitCode = code;
+}

package/src/config.ts

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { CliError } from "./errors";
+import { ExitCode } from "./types";
+
+interface ConfigFile {
+  serpApiKey?: unknown;
+}
+
+export function resolveApiKey(env: NodeJS.ProcessEnv = process.env, homeDir = os.homedir()): string {
+  const envKey = env.SERPAPI_API_KEY?.trim();
+  if (envKey) {
+    return envKey;
+  }
+
+  const configPath = path.join(homeDir, ".config", "wayfinder", "config.json");
+
+  if (!existsSync(configPath)) {
+    throw missingKeyError();
+  }
+
+  let parsed: ConfigFile;
+  try {
+    const raw = readFileSync(configPath, "utf8");
+    parsed = JSON.parse(raw) as ConfigFile;
+  } catch {
+    throw new CliError(
+      "Could not read ~/.config/wayfinder/config.json. Ensure it is valid JSON.",
+      ExitCode.MissingApiKey,
+    );
+  }
+
+  if (typeof parsed.serpApiKey !== "string" || parsed.serpApiKey.trim() === "") {
+    throw missingKeyError();
+  }
+
+  return parsed.serpApiKey.trim();
+}
+
+function missingKeyError(): CliError {
+  return new CliError(
+    "Missing SerpApi key. Set SERPAPI_API_KEY or add ~/.config/wayfinder/config.json with {\"serpApiKey\":\"...\"}.",
+    ExitCode.MissingApiKey,
+  );
+}

package/src/errors.ts

@@ -0,0 +1,9 @@
+export class CliError extends Error {
+  readonly exitCode: number;
+
+  constructor(message: string, exitCode: number) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+}

package/src/format.ts

@@ -0,0 +1,102 @@
+import { FlightOption } from "./types";
+
+const currencyFormatter = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  maximumFractionDigits: 0,
+});
+
+export function renderTable(options: FlightOption[]): string {
+  const rows = options.map((option) => ({
+    price: currencyFormatter.format(option.price),
+    airline: option.airline,
+    depart: option.departureTime,
+    arrive: option.arrivalTime,
+    duration: formatDuration(option.durationMinutes),
+    stops: String(option.stops),
+  }));
+
+  const headers = {
+    price: "PRICE",
+    airline: "AIRLINE",
+    depart: "DEPART",
+    arrive: "ARRIVE",
+    duration: "DURATION",
+    stops: "STOPS",
+  };
+
+  const widths = {
+    price: maxWidth(rows, "price", headers.price),
+    airline: maxWidth(rows, "airline", headers.airline),
+    depart: maxWidth(rows, "depart", headers.depart),
+    arrive: maxWidth(rows, "arrive", headers.arrive),
+    duration: maxWidth(rows, "duration", headers.duration),
+    stops: maxWidth(rows, "stops", headers.stops),
+  };
+
+  const lines: string[] = [];
+
+  lines.push(
+    [
+      headers.price.padEnd(widths.price),
+      headers.airline.padEnd(widths.airline),
+      headers.depart.padEnd(widths.depart),
+      headers.arrive.padEnd(widths.arrive),
+      headers.duration.padEnd(widths.duration),
+      headers.stops.padEnd(widths.stops),
+    ].join("  "),
+  );
+
+  lines.push(
+    [
+      "-".repeat(widths.price),
+      "-".repeat(widths.airline),
+      "-".repeat(widths.depart),
+      "-".repeat(widths.arrive),
+      "-".repeat(widths.duration),
+      "-".repeat(widths.stops),
+    ].join("  "),
+  );
+
+  for (const row of rows) {
+    lines.push(
+      [
+        row.price.padEnd(widths.price),
+        row.airline.padEnd(widths.airline),
+        row.depart.padEnd(widths.depart),
+        row.arrive.padEnd(widths.arrive),
+        row.duration.padEnd(widths.duration),
+        row.stops.padEnd(widths.stops),
+      ].join("  "),
+    );
+  }
+
+  return lines.join("\n");
+}
+
+function maxWidth(
+  rows: Array<Record<string, string>>,
+  key: string,
+  header: string,
+): number {
+  return rows.reduce((width, row) => Math.max(width, row[key].length), header.length);
+}
+
+function formatDuration(totalMinutes: number): string {
+  if (!Number.isFinite(totalMinutes) || totalMinutes <= 0) {
+    return "n/a";
+  }
+
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+
+  if (hours === 0) {
+    return `${minutes}m`;
+  }
+
+  if (minutes === 0) {
+    return `${hours}h`;
+  }
+
+  return `${hours}h ${minutes}m`;
+}

package/src/parse.ts

@@ -0,0 +1,228 @@
+import { CliError } from "./errors";
+import { ExitCode, ParsedArgs } from "./types";
+
+interface RawOptions {
+  from?: string;
+  to?: string;
+  date?: string;
+  airline?: string;
+  maxStops?: string;
+  maxPrice?: string;
+  departAfter?: string;
+  departBefore?: string;
+  outputJson: boolean;
+  help: boolean;
+}
+
+const HELP_FLAGS = new Set(["-h", "--help"]);
+
+export function parseCliArgs(argv: string[]): ParsedArgs {
+  const args = stripSubcommands(argv);
+  const raw: RawOptions = {
+    outputJson: false,
+    help: false,
+  };
+
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+
+    if (HELP_FLAGS.has(token)) {
+      raw.help = true;
+      continue;
+    }
+
+    if (token === "--json") {
+      raw.outputJson = true;
+      continue;
+    }
+
+    if (!token.startsWith("--")) {
+      throw new CliError(`Unexpected argument: ${token}`, ExitCode.InvalidInput);
+    }
+
+    const value = args[i + 1];
+    if (!value || value.startsWith("--")) {
+      throw new CliError(`Missing value for ${token}`, ExitCode.InvalidInput);
+    }
+
+    switch (token) {
+      case "--from":
+        raw.from = value;
+        break;
+      case "--to":
+        raw.to = value;
+        break;
+      case "--date":
+        raw.date = value;
+        break;
+      case "--airline":
+        raw.airline = value;
+        break;
+      case "--max-stops":
+        raw.maxStops = value;
+        break;
+      case "--max-price":
+        raw.maxPrice = value;
+        break;
+      case "--depart-after":
+        raw.departAfter = value;
+        break;
+      case "--depart-before":
+        raw.departBefore = value;
+        break;
+      default:
+        throw new CliError(`Unknown flag: ${token}`, ExitCode.InvalidInput);
+    }
+
+    i += 1;
+  }
+
+  if (raw.help) {
+    return {
+      help: true,
+      outputJson: raw.outputJson,
+    };
+  }
+
+  if (!raw.from || !raw.to || !raw.date) {
+    throw new CliError("Missing required flags: --from, --to, --date", ExitCode.InvalidInput);
+  }
+
+  const origin = normalizeAirport(raw.from, "origin");
+  const destination = normalizeAirport(raw.to, "destination");
+
+  if (origin === destination) {
+    throw new CliError("Origin and destination must be different airports", ExitCode.InvalidInput);
+  }
+
+  const departureDate = normalizeDate(raw.date);
+  const airlineCode = raw.airline ? normalizeAirlineCode(raw.airline) : undefined;
+  const maxStops = raw.maxStops ? normalizeMaxStops(raw.maxStops) : undefined;
+  const maxPrice = raw.maxPrice ? normalizeMaxPrice(raw.maxPrice) : undefined;
+
+  const hasDepartAfter = typeof raw.departAfter === "string";
+  const hasDepartBefore = typeof raw.departBefore === "string";
+
+  if (hasDepartAfter !== hasDepartBefore) {
+    throw new CliError(
+      "Departure window requires both --depart-after and --depart-before",
+      ExitCode.InvalidInput,
+    );
+  }
+
+  let departureAfterMinutes: number | undefined;
+  let departureBeforeMinutes: number | undefined;
+
+  if (hasDepartAfter && hasDepartBefore) {
+    departureAfterMinutes = normalizeTime(raw.departAfter as string, "--depart-after");
+    departureBeforeMinutes = normalizeTime(raw.departBefore as string, "--depart-before");
+
+    if (departureAfterMinutes >= departureBeforeMinutes) {
+      throw new CliError(
+        "Departure window must be on the same day and --depart-after must be earlier than --depart-before",
+        ExitCode.InvalidInput,
+      );
+    }
+  }
+
+  return {
+    help: false,
+    outputJson: raw.outputJson,
+    query: {
+      origin,
+      destination,
+      departureDate,
+      airlineCode,
+      maxStops,
+      maxPrice,
+      departureAfterMinutes,
+      departureBeforeMinutes,
+    },
+  };
+}
+
+function stripSubcommands(argv: string[]): string[] {
+  const args = [...argv];
+
+  if (args[0] === "flights") {
+    args.shift();
+    if (args[0] === "one-way") {
+      args.shift();
+    }
+  }
+
+  return args;
+}
+
+function normalizeAirport(value: string, fieldName: "origin" | "destination"): string {
+  const upper = value.trim().toUpperCase();
+  if (!/^[A-Z]{3}$/.test(upper)) {
+    throw new CliError(
+      `Invalid ${fieldName} airport code: ${value}. Expected a 3 letter IATA code.`,
+      ExitCode.InvalidInput,
+    );
+  }
+  return upper;
+}
+
+function normalizeAirlineCode(value: string): string {
+  const upper = value.trim().toUpperCase();
+  if (!/^[A-Z0-9]{2}$/.test(upper)) {
+    throw new CliError(
+      `Invalid airline code: ${value}. Expected a 2 character IATA airline code.`,
+      ExitCode.InvalidInput,
+    );
+  }
+  return upper;
+}
+
+function normalizeDate(value: string): string {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) {
+    throw new CliError("Invalid date. Expected YYYY-MM-DD", ExitCode.InvalidInput);
+  }
+
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+
+  const date = new Date(year, month - 1, day);
+  if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day) {
+    throw new CliError("Invalid departure date", ExitCode.InvalidInput);
+  }
+
+  const today = new Date();
+  today.setHours(0, 0, 0, 0);
+  date.setHours(0, 0, 0, 0);
+
+  if (date < today) {
+    throw new CliError("Departure date cannot be in the past", ExitCode.InvalidInput);
+  }
+
+  return value;
+}
+
+function normalizeMaxStops(value: string): number {
+  const numeric = Number.parseInt(value, 10);
+  if (!Number.isInteger(numeric) || numeric < 0 || numeric > 2) {
+    throw new CliError("--max-stops must be an integer between 0 and 2", ExitCode.InvalidInput);
+  }
+  return numeric;
+}
+
+function normalizeMaxPrice(value: string): number {
+  const numeric = Number.parseInt(value, 10);
+  if (!Number.isInteger(numeric) || numeric <= 0) {
+    throw new CliError("--max-price must be a positive integer", ExitCode.InvalidInput);
+  }
+  return numeric;
+}
+
+function normalizeTime(value: string, flagName: string): number {
+  const match = /^([01]\d|2[0-3]):([0-5]\d)$/.exec(value);
+  if (!match) {
+    throw new CliError(`${flagName} must be in HH:MM 24 hour format`, ExitCode.InvalidInput);
+  }
+
+  return Number(match[1]) * 60 + Number(match[2]);
+}

package/src/serpapi.ts

@@ -0,0 +1,208 @@
+import { CliError } from "./errors";
+import { ExitCode, FlightOption, FlightQuery } from "./types";
+
+interface SerpApiAirport {
+  time?: string;
+}
+
+interface SerpApiSegment {
+  airline?: string;
+  duration?: number;
+  departure_airport?: SerpApiAirport;
+  arrival_airport?: SerpApiAirport;
+}
+
+interface SerpApiItinerary {
+  price?: number;
+  total_duration?: number;
+  flights?: SerpApiSegment[];
+}
+
+interface SerpApiResponse {
+  error?: string;
+  best_flights?: SerpApiItinerary[];
+  other_flights?: SerpApiItinerary[];
+}
+
+export async function searchFlights(
+  query: FlightQuery,
+  apiKey: string,
+  fetchImpl: typeof fetch = fetch,
+): Promise<FlightOption[]> {
+  const requestUrl = buildRequestUrl(query, apiKey);
+
+  let response: Response;
+  try {
+    response = await fetchImpl(requestUrl, {
+      signal: AbortSignal.timeout(15_000),
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "TimeoutError") {
+      throw new CliError("SerpApi request timed out", ExitCode.ApiFailure);
+    }
+
+    throw new CliError("Failed to reach SerpApi", ExitCode.ApiFailure);
+  }
+
+  if (!response.ok) {
+    throw new CliError(`SerpApi request failed with status ${response.status}`, ExitCode.ApiFailure);
+  }
+
+  let payload: SerpApiResponse;
+  try {
+    payload = (await response.json()) as SerpApiResponse;
+  } catch {
+    throw new CliError("SerpApi returned invalid JSON", ExitCode.ApiFailure);
+  }
+
+  if (typeof payload.error === "string" && payload.error.trim() !== "") {
+    throw new CliError(`SerpApi error: ${payload.error}`, ExitCode.ApiFailure);
+  }
+
+  let flights = shapeSerpApiResponse(payload);
+
+  if (
+    typeof query.departureAfterMinutes === "number" &&
+    typeof query.departureBeforeMinutes === "number"
+  ) {
+    flights = filterByDepartureWindow(
+      flights,
+      query.departureAfterMinutes,
+      query.departureBeforeMinutes,
+    );
+  }
+
+  flights.sort((a, b) => a.price - b.price);
+  return flights;
+}
+
+export function shapeSerpApiResponse(payload: SerpApiResponse): FlightOption[] {
+  const merged = [...(payload.best_flights ?? []), ...(payload.other_flights ?? [])];
+
+  return merged
+    .map((itinerary) => shapeItinerary(itinerary))
+    .filter((option): option is FlightOption => option !== null);
+}
+
+export function filterByDepartureWindow(
+  options: FlightOption[],
+  minMinutes: number,
+  maxMinutes: number,
+): FlightOption[] {
+  return options.filter((option) => {
+    const minutes = extractMinutes(option.departureTime);
+    if (minutes === null) {
+      return true;
+    }
+
+    return minutes >= minMinutes && minutes <= maxMinutes;
+  });
+}
+
+function shapeItinerary(itinerary: SerpApiItinerary): FlightOption | null {
+  if (!Number.isFinite(itinerary.price)) {
+    return null;
+  }
+
+  const segments = Array.isArray(itinerary.flights) ? itinerary.flights : [];
+  if (segments.length === 0) {
+    return null;
+  }
+
+  const first = segments[0];
+  const last = segments[segments.length - 1];
+
+  const departureTime = first.departure_airport?.time;
+  const arrivalTime = last.arrival_airport?.time;
+
+  if (!departureTime || !arrivalTime) {
+    return null;
+  }
+
+  const uniqueAirlines = [...new Set(segments.map((segment) => segment.airline).filter(Boolean))];
+
+  return {
+    price: itinerary.price as number,
+    airline: uniqueAirlines.length > 0 ? uniqueAirlines.join(", ") : "Unknown",
+    departureTime,
+    arrivalTime,
+    durationMinutes: inferDurationMinutes(itinerary, segments),
+    stops: Math.max(0, segments.length - 1),
+  };
+}
+
+function inferDurationMinutes(itinerary: SerpApiItinerary, segments: SerpApiSegment[]): number {
+  if (Number.isFinite(itinerary.total_duration)) {
+    return itinerary.total_duration as number;
+  }
+
+  const segmentDuration = segments.reduce((total, segment) => {
+    if (!Number.isFinite(segment.duration)) {
+      return total;
+    }
+    return total + (segment.duration as number);
+  }, 0);
+
+  return segmentDuration;
+}
+
+function buildRequestUrl(query: FlightQuery, apiKey: string): string {
+  const url = new URL("https://serpapi.com/search.json");
+
+  url.searchParams.set("engine", "google_flights");
+  url.searchParams.set("type", "2");
+  url.searchParams.set("departure_id", query.origin);
+  url.searchParams.set("arrival_id", query.destination);
+  url.searchParams.set("outbound_date", query.departureDate);
+  url.searchParams.set("sort_by", "2");
+  url.searchParams.set("currency", "USD");
+  url.searchParams.set("api_key", apiKey);
+
+  if (query.airlineCode) {
+    url.searchParams.set("include_airlines", query.airlineCode);
+  }
+
+  if (typeof query.maxStops === "number") {
+    url.searchParams.set("stops", toSerpApiStopsFilter(query.maxStops));
+  }
+
+  if (typeof query.maxPrice === "number") {
+    url.searchParams.set("max_price", String(query.maxPrice));
+  }
+
+  if (
+    typeof query.departureAfterMinutes === "number" &&
+    typeof query.departureBeforeMinutes === "number"
+  ) {
+    const minHour = Math.floor(query.departureAfterMinutes / 60);
+    const maxHour = Math.max(
+      minHour,
+      Math.floor(Math.max(0, query.departureBeforeMinutes - 1) / 60),
+    );
+
+    url.searchParams.set("outbound_times", `${minHour},${maxHour}`);
+  }
+
+  return url.toString();
+}
+
+function toSerpApiStopsFilter(maxStops: number): string {
+  if (maxStops === 0) {
+    return "1";
+  }
+
+  if (maxStops === 1) {
+    return "2";
+  }
+
+  return "3";
+}
+
+function extractMinutes(value: string): number | null {
+  const match = /\b([01]?\d|2[0-3]):([0-5]\d)\b/.exec(value);
+  if (!match) {
+    return null;
+  }
+
+  return Number(match[1]) * 60 + Number(match[2]);
+}

package/src/types.ts

@@ -0,0 +1,36 @@
+export const ExitCode = {
+  Success: 0,
+  InternalError: 1,
+  InvalidInput: 2,
+  MissingApiKey: 3,
+  ApiFailure: 4,
+  NoResults: 5,
+} as const;
+
+export type ExitCodeValue = (typeof ExitCode)[keyof typeof ExitCode];
+
+export interface FlightQuery {
+  origin: string;
+  destination: string;
+  departureDate: string;
+  airlineCode?: string;
+  maxStops?: number;
+  maxPrice?: number;
+  departureAfterMinutes?: number;
+  departureBeforeMinutes?: number;
+}
+
+export interface ParsedArgs {
+  query?: FlightQuery;
+  outputJson: boolean;
+  help: boolean;
+}
+
+export interface FlightOption {
+  price: number;
+  airline: string;
+  departureTime: string;
+  arrivalTime: string;
+  durationMinutes: number;
+  stops: number;
+}