straeto 0.1.0

package/src/cli.test.ts

@@ -0,0 +1,189 @@
+import { describe, expect, test } from "bun:test";
+
+const CLI = ["bun", "run", "src/cli.ts"];
+
+async function run(
+	...args: string[]
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+	const proc = Bun.spawn([...CLI, ...args], {
+		stdout: "pipe",
+		stderr: "pipe",
+		env: { ...process.env, FORCE_COLOR: "0" },
+	});
+	const [stdout, stderr] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+	]);
+	const exitCode = await proc.exited;
+	return { stdout, stderr, exitCode };
+}
+
+describe("cli --help", () => {
+	test("shows usage and all commands", async () => {
+		const { stdout, exitCode } = await run("--help");
+
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("Usage: straeto");
+		expect(stdout).toContain("route");
+		expect(stdout).toContain("stops");
+		expect(stdout).toContain("stop");
+		expect(stdout).toContain("alerts");
+		expect(stdout).toContain("plan");
+	});
+});
+
+describe("cli --version", () => {
+	test("prints version number", async () => {
+		const { stdout, exitCode } = await run("--version");
+
+		expect(exitCode).toBe(0);
+		expect(stdout.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+	});
+
+	test("works with -v shorthand", async () => {
+		const { stdout, exitCode } = await run("-v");
+
+		expect(exitCode).toBe(0);
+		expect(stdout.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+	});
+});
+
+describe("cli route", () => {
+	test("shows bus overview for a route", async () => {
+		const { stdout, exitCode } = await run("route", "3");
+
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("Route 3");
+	});
+
+	test("shows help for route command", async () => {
+		const { stdout, exitCode } = await run("route", "--help");
+
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("Route number");
+		expect(stdout).toContain("--watch");
+		expect(stdout).toContain("--interval");
+	});
+
+	test("fails without route argument", async () => {
+		const { stderr, exitCode } = await run("route");
+
+		expect(exitCode).toBe(1);
+		expect(stderr).toContain("missing required argument");
+	});
+});
+
+describe("cli stops", () => {
+	test("lists stops with default limit", async () => {
+		const { stdout, exitCode } = await run("stops");
+
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("Bus stops");
+		expect(stdout).toContain("more");
+	});
+
+	test("filters stops by search", async () => {
+		const { stdout, exitCode } = await run("stops", "-s", "Hamraborg");
+
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("Hamraborg");
+	});
+
+	test("respects -n limit flag", async () => {
+		const { stdout, exitCode } = await run("stops", "-n", "3");
+
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("Bus stops");
+		// Should show "and N more" since 3 is less than total
+		expect(stdout).toContain("more");
+	});
+});
+
+describe("cli stop", () => {
+	test("looks up a stop by name", async () => {
+		const { stdout, exitCode } = await run("stop", "Hamraborg");
+
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("Hamraborg");
+	});
+
+	test("shows suggestions for partial match", async () => {
+		const { stdout, exitCode } = await run("stop", "Hamra");
+
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("Hamraborg");
+	});
+
+	test("fails for nonexistent stop", async () => {
+		const { stderr, exitCode } = await run("stop", "xyznonexistent123");
+
+		expect(exitCode).toBe(1);
+		expect(stderr).toContain("No stops matching");
+	});
+});
+
+describe("cli alerts", () => {
+	test("shows alerts in Icelandic by default", async () => {
+		const { stdout, exitCode } = await run("alerts");
+
+		expect(exitCode).toBe(0);
+		// May have 0 alerts, but should still show the header or "No active alerts"
+		expect(stdout.length).toBeGreaterThan(0);
+	});
+
+	test("shows alerts in English with -l EN", async () => {
+		const { stdout, exitCode } = await run("alerts", "-l", "EN");
+
+		expect(exitCode).toBe(0);
+		expect(stdout.length).toBeGreaterThan(0);
+	});
+});
+
+describe("cli plan", () => {
+	test("plans a trip with coordinates", async () => {
+		// Use tomorrow to avoid time-of-day edge cases
+		const tomorrow = new Date(Date.now() + 86400000);
+		const date = tomorrow.toISOString().slice(0, 10);
+		const { stdout, exitCode } = await run(
+			"plan",
+			"-f",
+			"64.1426,-21.9009",
+			"-t",
+			"64.1117,-21.8437",
+			"--at",
+			"10:00",
+			"-d",
+			date,
+		);
+
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("→");
+	});
+
+	test("fails without from/to in non-interactive mode", async () => {
+		const { stderr, exitCode } = await run("plan", "-f", "64.14,-21.90");
+
+		expect(exitCode).toBe(1);
+		expect(stderr).toContain("Missing --from and --to");
+	});
+
+	test("shows help for plan command", async () => {
+		const { stdout, exitCode } = await run("plan", "--help");
+
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("--from");
+		expect(stdout).toContain("--to");
+		expect(stdout).toContain("--at");
+		expect(stdout).toContain("--by");
+		expect(stdout).toContain("--interactive");
+	});
+});
+
+describe("cli unknown command", () => {
+	test("shows error for unknown command", async () => {
+		const { stderr, exitCode } = await run("foobar");
+
+		expect(exitCode).toBe(1);
+		expect(stderr).toContain("unknown command");
+	});
+});

package/src/cli.ts

@@ -0,0 +1,94 @@
+#!/usr/bin/env bun
+import chalk from "chalk";
+import { program } from "commander";
+import { alertsCommand } from "./commands/alerts";
+import { planCommand } from "./commands/plan";
+import { routeCommand } from "./commands/route";
+import { AlertsOpts, PlanOpts, RouteOpts, StopsOpts } from "./commands/schemas";
+import { stopCommand } from "./commands/stop";
+import { stopsCommand } from "./commands/stops";
+import { writeErr } from "./terminal";
+
+function handleError(error: unknown) {
+	const msg = error instanceof Error ? error.message : String(error);
+	writeErr(`${chalk.red("Error:")} ${msg}`);
+	process.exit(1);
+}
+
+program
+	.name("straeto")
+	.description("Strætó — Icelandic bus system CLI")
+	.version("0.1.0", "-v, --version");
+
+program
+	.command("route")
+	.description("Show buses on a route, or detail a specific bus (e.g. route 3 A)")
+	.argument("<route>", "Route number")
+	.argument("[bus]", "Bus letter for detail view (e.g. A)")
+	.option("-w, --watch", "Live-track with updates every second")
+	.option("-i, --interval <ms>", "Poll interval in ms (with --watch)", "1000")
+	.action(async (route: string, busLetter: string | undefined, rawOpts) => {
+		try {
+			await routeCommand(route, busLetter, RouteOpts.parse(rawOpts));
+		} catch (error) {
+			handleError(error);
+		}
+	});
+
+program
+	.command("stops")
+	.description("List all bus stops")
+	.option("-r, --route <route>", "Filter by route number")
+	.option("-s, --search <query>", "Search stops by name")
+	.option("-n, --limit <n>", "Limit results", "10")
+	.option("-a, --all", "Show all results")
+	.action(async (rawOpts) => {
+		try {
+			await stopsCommand(StopsOpts.parse(rawOpts));
+		} catch (error) {
+			handleError(error);
+		}
+	});
+
+program
+	.command("stop")
+	.description("Show details for a specific stop (by ID or name)")
+	.argument("<query...>", "Stop ID or name")
+	.action(async (parts: string[]) => {
+		try {
+			await stopCommand(parts);
+		} catch (error) {
+			handleError(error);
+		}
+	});
+
+program
+	.command("alerts")
+	.description("Show active service alerts")
+	.option("-l, --lang <lang>", "Language (IS or EN)", "IS")
+	.action(async (rawOpts) => {
+		try {
+			await alertsCommand(AlertsOpts.parse(rawOpts));
+		} catch (error) {
+			handleError(error);
+		}
+	});
+
+program
+	.command("plan")
+	.description("Plan a trip between two locations")
+	.option("-f, --from <coords>", "Origin as lat,lon")
+	.option("-t, --to <coords>", "Destination as lat,lon")
+	.option("-i, --interactive", "Interactive mode — search for places by name")
+	.option("-d, --date <date>", "Date (YYYY-MM-DD, defaults to today)")
+	.option("--at <time>", "Depart at time (HH:MM, defaults to now)")
+	.option("--by <time>", "Arrive by time (HH:MM)")
+	.action(async (rawOpts) => {
+		try {
+			await planCommand(PlanOpts.parse(rawOpts));
+		} catch (error) {
+			handleError(error);
+		}
+	});
+
+program.parse();

package/src/commands/alerts.ts

@@ -0,0 +1,10 @@
+import type { z } from "zod/v4";
+import * as api from "../api";
+import * as fmt from "../format";
+import { writeLn } from "../terminal";
+import type { AlertsOpts } from "./schemas";
+
+export async function alertsCommand(opts: z.infer<typeof AlertsOpts>) {
+	const alerts = await api.getAlerts(opts.lang);
+	writeLn(fmt.formatAlerts(alerts));
+}

package/src/commands/plan.ts

@@ -0,0 +1,36 @@
+import type { z } from "zod/v4";
+import * as api from "../api";
+import * as fmt from "../format";
+import { writeLn } from "../terminal";
+import type { PlanOpts } from "./schemas";
+
+export async function planCommand(opts: z.infer<typeof PlanOpts>) {
+	const date = opts.date ?? fmt.currentDate();
+	let arrivalBy = !!opts.by;
+	let time = opts.by ?? opts.at ?? fmt.currentTime();
+
+	let from = opts.from;
+	let to = opts.to;
+
+	if (opts.interactive || (!from && !to)) {
+		const { promptLocation, promptTimeMode } = await import("../prompt");
+		writeLn("");
+		const origin = await promptLocation("From", api.geocode);
+		const dest = await promptLocation("To", api.geocode);
+		from = `${origin.lat},${origin.lon}`;
+		to = `${dest.lat},${dest.lon}`;
+
+		if (!opts.at && !opts.by) {
+			const mode = await promptTimeMode();
+			time = mode.time;
+			arrivalBy = mode.arrivalBy;
+		}
+
+		writeLn("");
+	}
+
+	if (!from || !to) throw new Error("Missing --from and --to (or use -i for interactive mode)");
+
+	const trips = await api.planTrip({ from, to, date, time, arrivalBy });
+	writeLn(fmt.formatTrips(trips));
+}

package/src/commands/route.ts

@@ -0,0 +1,88 @@
+import chalk from "chalk";
+import type { z } from "zod/v4";
+import * as api from "../api";
+import * as fmt from "../format";
+import { ANSI, write, writeLn } from "../terminal";
+import type { RouteOpts } from "./schemas";
+
+export async function routeCommand(
+	route: string,
+	busLetter: string | undefined,
+	opts: z.infer<typeof RouteOpts>,
+) {
+	let allStops: api.Stop[] | null = null;
+	const getStops = async () => {
+		if (!allStops) allStops = await api.getStops();
+		return allStops;
+	};
+
+	const render = async () => {
+		const data = await api.getBusLocations([route]);
+		if (busLetter) {
+			const match = api.findBus(data.results, route, busLetter);
+			if (!match) {
+				if (opts.watch)
+					return chalk.dim(`Bus ${route}-${busLetter.toUpperCase()} not currently active.`);
+				throw new Error(`Bus ${route}-${busLetter.toUpperCase()} not found.`);
+			}
+			const stops = await getStops();
+			const lastStop = api.findLastStop(match, stops);
+			return fmt.formatBusDetail(match, data.lastUpdate, lastStop);
+		}
+		return fmt.formatBusOverview(route, data.results, data.lastUpdate);
+	};
+
+	if (opts.watch) {
+		const interval = parseInt(opts.interval, 10);
+		const label = busLetter ? `bus ${route}-${busLetter.toUpperCase()}` : `route ${route}`;
+		const spinner = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+		let prevLineCount = 0;
+		let tick = 0;
+		let lastOutput = "";
+
+		const drawFrame = async () => {
+			const dot = chalk.cyan(spinner[tick++ % spinner.length]);
+			const footer = `\n  ${dot} ${chalk.dim(`Live · ${label} · Ctrl+C to stop`)}`;
+			const frame = lastOutput + footer;
+			const lines = frame.split("\n");
+
+			let buf = prevLineCount > 0 ? ANSI.moveToStart(prevLineCount) : "";
+			for (const line of lines) buf += `${line + ANSI.clearLine}\n`;
+			for (let idx = lines.length; idx < prevLineCount; idx++) buf += `${ANSI.clearLine}\n`;
+			await write(buf);
+			prevLineCount = Math.max(lines.length, prevLineCount);
+		};
+
+		const fetchData = async () => {
+			try {
+				lastOutput = await render();
+			} catch {
+				// silently retry on transient errors
+			}
+		};
+
+		await write(ANSI.hideCursor);
+		process.on("SIGINT", async () => {
+			await write(ANSI.showCursor);
+			process.exit(0);
+		});
+
+		await fetchData();
+
+		// Data polling in background
+		(async () => {
+			while (true) {
+				await Bun.sleep(interval);
+				await fetchData();
+			}
+		})();
+
+		// Fast spinner render loop
+		while (true) {
+			await drawFrame();
+			await Bun.sleep(80);
+		}
+	} else {
+		writeLn(await render());
+	}
+}

package/src/commands/schemas.ts

@@ -0,0 +1,26 @@
+import { z } from "zod/v4";
+
+export const RouteOpts = z.object({
+	watch: z.boolean().optional(),
+	interval: z.string(),
+});
+
+export const StopsOpts = z.object({
+	route: z.string().optional(),
+	search: z.string().optional(),
+	limit: z.string(),
+	all: z.boolean().optional(),
+});
+
+export const AlertsOpts = z.object({
+	lang: z.string(),
+});
+
+export const PlanOpts = z.object({
+	from: z.string().optional(),
+	to: z.string().optional(),
+	interactive: z.boolean().optional(),
+	date: z.string().optional(),
+	at: z.string().optional(),
+	by: z.string().optional(),
+});

package/src/commands/stop.ts

@@ -0,0 +1,37 @@
+import chalk from "chalk";
+import * as api from "../api";
+import * as fmt from "../format";
+import { writeLn } from "../terminal";
+
+export async function stopCommand(parts: string[]) {
+	const input = parts.join(" ");
+	const isId = /^\d+$/.test(input);
+
+	if (isId) {
+		const stop = await api.getStop(input);
+		if (!stop) throw new Error(`Stop "${input}" not found.`);
+		writeLn(fmt.formatStop(stop));
+		return;
+	}
+
+	const stops = await api.getStops();
+	const query = input.toLowerCase();
+	const matches = stops.filter((stop) => stop.name.toLowerCase() === query);
+
+	if (matches.length === 0) {
+		const fuzzy = stops.filter((stop) => stop.name.toLowerCase().includes(query));
+		if (fuzzy.length === 0) throw new Error(`No stops matching "${input}".`);
+		writeLn(chalk.dim(`No exact match. Did you mean:\n`));
+		writeLn(fmt.formatStops(fuzzy.slice(0, 10)));
+		return;
+	}
+
+	if (matches.length === 1) {
+		const stop = await api.getStop(String(matches[0]?.id));
+		if (!stop) throw new Error(`Stop "${input}" not found.`);
+		writeLn(fmt.formatStop(stop));
+	} else {
+		writeLn(chalk.dim(`Multiple stops named "${input}":\n`));
+		writeLn(fmt.formatStops(matches));
+	}
+}

package/src/commands/stops.ts

@@ -0,0 +1,30 @@
+import chalk from "chalk";
+import type { z } from "zod/v4";
+import * as api from "../api";
+import * as fmt from "../format";
+import { writeLn } from "../terminal";
+import type { StopsOpts } from "./schemas";
+
+export async function stopsCommand(opts: z.infer<typeof StopsOpts>) {
+	let stops = await api.getStops();
+
+	if (opts.route) {
+		const routeFilter = opts.route;
+		stops = stops.filter((stop) => stop.routes.includes(routeFilter));
+	}
+
+	if (opts.search) {
+		const query = opts.search.toLowerCase();
+		stops = stops.filter((stop) => stop.name.toLowerCase().includes(query));
+	}
+
+	const total = stops.length;
+	if (!opts.all) {
+		stops = stops.slice(0, parseInt(opts.limit, 10));
+	}
+
+	writeLn(fmt.formatStops(stops));
+	if (!opts.all && total > stops.length) {
+		writeLn(chalk.dim(`\n  … and ${total - stops.length} more (use --all to show all)`));
+	}
+}