straeto 0.1.0

package/src/format.ts

@@ -0,0 +1,230 @@
+import chalk from "chalk";
+import type {
+	Alert,
+	BusLocation,
+	GeoResult,
+	NextStop,
+	Stop,
+	StopDetail,
+	TripItinerary,
+} from "./api";
+
+const routeColor = chalk.bold.yellow;
+const stopColor = chalk.cyan;
+const dimText = chalk.dim;
+const heading = chalk.bold.underline;
+
+export function currentDate(): string {
+	const now = new Date();
+	return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+}
+
+export function currentTime(): string {
+	const now = new Date();
+	return `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
+}
+
+function stripHtml(html: string): string {
+	return html
+		.replace(/<br\s*\/?>/gi, "\n")
+		.replace(/<[^>]+>/g, "")
+		.trim();
+}
+
+function formatTime(iso: string): string {
+	return new Date(iso).toLocaleTimeString("is-IS", {
+		hour: "2-digit",
+		minute: "2-digit",
+	});
+}
+
+function formatDuration(seconds: number): string {
+	const mins = Math.round(seconds / 60);
+	if (mins < 60) return `${mins} mín`;
+	const hours = Math.floor(mins / 60);
+	return `${hours}h ${mins % 60}m`;
+}
+
+function busLetter(busId: string): string {
+	return busId.split("-").pop() ?? busId;
+}
+
+function nearestStopLabel(nextStops: NextStop[]): string {
+	const valid = nextStops.filter((nextStop) => nextStop.stop != null);
+	if (valid.length === 0) return dimText("—");
+	const first = valid[0];
+	if (!first) return dimText("—");
+	const mins = first.waitingTime;
+	const name = first.stop?.name ?? "?";
+	if (mins <= 1) return `at ${stopColor(name)}`;
+	return `near ${stopColor(name)} ${dimText(`(${mins} mín)`)}`;
+}
+
+export function formatBusOverview(route: string, buses: BusLocation[], lastUpdate: string): string {
+	if (buses.length === 0) return dimText("No buses currently running on this route.");
+
+	// Find the longest headsign for alignment
+	const maxHeadsign = Math.max(...buses.map((bus) => bus.headsign.length));
+
+	const lines = [
+		`${routeColor(`Route ${route}`)} ${dimText(`— ${buses.length} bus${buses.length !== 1 ? "es" : ""}`)}${" ".repeat(Math.max(0, maxHeadsign + 20 - route.length))}${dimText(formatTime(lastUpdate))}`,
+		"",
+	];
+
+	for (const bus of buses) {
+		const letter = chalk.bold(busLetter(bus.busId));
+		const headsign = bus.headsign.padEnd(maxHeadsign);
+		const location = nearestStopLabel(bus.nextStops);
+		lines.push(`  ${letter}  ${dimText("→")} ${stopColor(headsign)}  ${location}`);
+	}
+
+	return lines.join("\n");
+}
+
+export function formatBusDetail(bus: BusLocation, lastUpdate: string, lastStop?: string): string {
+	const valid = bus.nextStops.filter((nextStop) => nextStop.stop != null);
+
+	const lines = [
+		`${routeColor(`Bus ${bus.busId}`)} ${dimText("→")} ${stopColor(bus.headsign)}${" ".repeat(20)}${dimText(formatTime(lastUpdate))}`,
+		"",
+	];
+
+	if (lastStop) {
+		lines.push(`  ${dimText("✓")} ${dimText(lastStop.padEnd(22))} ${dimText("passed")}`);
+	}
+
+	if (valid.length === 0) {
+		lines.push(`  ${dimText("No upcoming stops")}`);
+		return lines.join("\n");
+	}
+
+	for (let i = 0; i < valid.length; i++) {
+		const nextStop = valid[i];
+		if (!nextStop) continue;
+		const stopName = (nextStop.stop?.name ?? "?").padEnd(22);
+		const mins = nextStop.waitingTime;
+		const time = mins <= 1 ? dimText("< 1 mín") : dimText(`~${mins} mín`);
+		const isNext = i === 0;
+		const marker = isNext ? chalk.cyan("▸") : dimText("○");
+		const name = isNext ? chalk.bold.cyan(stopName) : stopColor(stopName);
+		lines.push(`  ${marker} ${name} ${time}`);
+	}
+
+	return lines.join("\n");
+}
+
+export function formatStops(stops: Stop[]): string {
+	const lines = [heading(`Bus stops`) + dimText(` (${stops.length} total)`), ""];
+
+	for (const stop of stops) {
+		const routes =
+			stop.routes.length > 0
+				? ` ${stop.routes.map((route) => routeColor(route)).join(dimText(", "))}`
+				: "";
+		const terminal = stop.isTerminal ? chalk.magenta(" ◉") : "";
+		lines.push(`  ${stopColor(stop.name)}${terminal}${routes}  ${dimText(`#${stop.id}`)}`);
+	}
+
+	return lines.join("\n");
+}
+
+export function formatStop(stop: StopDetail): string {
+	const lines = [
+		heading(stop.name) + (stop.isTerminal ? chalk.magenta(" Terminal") : ""),
+		"",
+		`  ${dimText("ID:")}      ${stop.id}`,
+		`  ${dimText("Coords:")}  ${stop.lat}, ${stop.lon}`,
+		`  ${dimText("Routes:")}  ${stop.routes.length > 0 ? stop.routes.map((route) => routeColor(route)).join(", ") : "none"}`,
+	];
+
+	return lines.join("\n");
+}
+
+export function formatAlerts(alerts: Alert[]): string {
+	if (alerts.length === 0) return dimText("No active alerts.");
+
+	const lines = [heading(`Alerts`) + dimText(` (${alerts.length})`), ""];
+
+	for (const alert of alerts) {
+		const routes = alert.routes.map((route) => routeColor(route)).join(", ");
+		lines.push(`  ${chalk.red("!")} ${chalk.bold(alert.title)}`);
+		lines.push(
+			`    ${dimText("Routes:")} ${routes}  ${dimText("Cause:")} ${alert.cause.toLowerCase().replace(/_/g, " ")}`,
+		);
+		lines.push(`    ${stripHtml(alert.text)}`);
+		lines.push("");
+	}
+
+	return lines.join("\n");
+}
+
+export function formatGeocode(results: GeoResult[]): string {
+	if (results.length === 0) return dimText("No results found.");
+
+	const lines = [heading(`Search results`), ""];
+
+	for (const result of results) {
+		lines.push(`  ${chalk.bold(result.name)}`);
+		lines.push(
+			`    ${dimText(result.address)}  ${dimText(`(${result.type})`)}  ${dimText(`${result.lat}, ${result.lon}`)}`,
+		);
+	}
+
+	return lines.join("\n");
+}
+
+export function formatTrips(trips: TripItinerary[]): string {
+	if (trips.length === 0) return dimText("No trips found.");
+
+	// Limit to best 5 options
+	const shown = trips.slice(0, 5);
+	const lines: string[] = [];
+
+	for (let i = 0; i < shown.length; i++) {
+		const trip = shown[i];
+		if (!trip) continue;
+		const start = formatTime(trip.time.from);
+		const end = formatTime(trip.time.to);
+		const dur = formatDuration(trip.duration.total);
+		const busLegs = trip.legs.filter((leg) => leg.type === "BUS");
+		const transfers = Math.max(0, busLegs.length - 1);
+
+		// Header line: time range and duration
+		const transferLabel =
+			transfers === 0
+				? chalk.green("Direct")
+				: `${transfers} transfer${transfers !== 1 ? "s" : ""}`;
+
+		lines.push(`  ${chalk.bold(start)} → ${chalk.bold(end)}  ${dimText(dur)}  ${transferLabel}`);
+
+		// Journey visualization
+		for (const leg of trip.legs) {
+			const fromName = leg.from.stop?.name ?? "";
+			const toName = leg.to.stop?.name ?? "";
+
+			if (leg.type === "WALK") {
+				const walkMins = formatDuration(leg.duration);
+				if (toName) {
+					lines.push(`  ${dimText("│")} ${dimText(`Walk ${walkMins} to ${toName}`)}`);
+				} else if (walkMins !== "0 mín") {
+					lines.push(`  ${dimText("│")} ${dimText(`Walk ${walkMins}`)}`);
+				}
+			} else {
+				const routeNr = leg.trip?.routeNr ?? "?";
+				const headsign = leg.trip?.headsign ?? toName;
+				const depTime = formatTime(leg.time.from);
+				const arrTime = formatTime(leg.time.to);
+				const stopCount = leg.stops?.length ?? 0;
+				const stopsLabel = stopCount > 0 ? dimText(` · ${stopCount} stops`) : "";
+
+				lines.push(`  ${routeColor(routeNr)} ${stopColor(fromName)}  ${depTime}`);
+				lines.push(`  ${dimText("│")} ${dimText(`→ ${headsign}`)}${stopsLabel}`);
+				lines.push(`  ${routeColor(routeNr)} ${stopColor(toName)}  ${arrTime}`);
+			}
+		}
+
+		if (i < shown.length - 1) lines.push("");
+	}
+
+	return lines.join("\n");
+}

package/src/prompt.ts

@@ -0,0 +1,252 @@
+import chalk from "chalk";
+import type { GeoResult } from "./api";
+import { currentTime } from "./format";
+import { ANSI, clearLines, disableRaw, enableRaw, readKey, write } from "./terminal";
+
+const MAX_SUGGESTIONS = 6;
+const DEBOUNCE_MS = 200;
+const MIN_QUERY_LEN = 2;
+
+function dedupeResults(results: GeoResult[], limit: number): GeoResult[] {
+	const seen = new Set<string>();
+	const unique: GeoResult[] = [];
+	for (const result of results) {
+		const key = `${result.name}|${result.address}`;
+		if (!seen.has(key)) {
+			seen.add(key);
+			unique.push(result);
+		}
+		if (unique.length >= limit) break;
+	}
+	return unique;
+}
+
+// --- Location prompt with autocomplete ---
+
+function renderLocationFrame(
+	label: string,
+	input: string,
+	suggestions: GeoResult[],
+	selected: number,
+): string {
+	let buf = `${ANSI.carriageReturn}${ANSI.clearLine}${chalk.bold(`${label}:`)} ${input}`;
+	for (let i = 0; i < suggestions.length; i++) {
+		const suggestion = suggestions[i];
+		if (!suggestion) continue;
+		const addr = suggestion.address ? chalk.dim(` — ${suggestion.address}`) : "";
+		const prefix = i === selected ? chalk.cyan("  ▸ ") : "    ";
+		const name = i === selected ? chalk.cyan.bold(suggestion.name) : suggestion.name;
+		buf += `\n${ANSI.clearLine}${prefix}${name}${addr}`;
+	}
+	return buf;
+}
+
+export async function promptLocation(
+	label: string,
+	geocode: (q: string) => Promise<GeoResult[]>,
+): Promise<{ lat: number; lon: number; name: string }> {
+	enableRaw();
+
+	let input = "";
+	let suggestions: GeoResult[] = [];
+	let selected = 0;
+	let prevLines = 0;
+	let debounceTimer: ReturnType<typeof setTimeout> | null = null;
+	let pendingQuery = "";
+
+	const draw = async () => {
+		await clearLines(prevLines);
+		const frame = renderLocationFrame(label, input, suggestions, selected);
+		await write(frame);
+		if (suggestions.length > 0) await write(ANSI.moveUp(suggestions.length));
+		const col = label.length + 2 + input.length;
+		await write(`${ANSI.carriageReturn}${ANSI.moveToCol(col + 1)}`);
+		prevLines = suggestions.length;
+	};
+
+	const scheduleSearch = () => {
+		if (debounceTimer) clearTimeout(debounceTimer);
+		if (input.length < MIN_QUERY_LEN) {
+			suggestions = [];
+			selected = 0;
+			return;
+		}
+		pendingQuery = input;
+		debounceTimer = setTimeout(async () => {
+			const query = pendingQuery;
+			try {
+				const results = await geocode(query);
+				if (pendingQuery === query) {
+					suggestions = dedupeResults(results, MAX_SUGGESTIONS);
+					selected = 0;
+					await draw();
+				}
+			} catch {}
+		}, DEBOUNCE_MS);
+	};
+
+	const finish = async (result: GeoResult) => {
+		await clearLines(prevLines);
+		await write(
+			`${ANSI.carriageReturn}${ANSI.clearLine}${chalk.bold(`${label}:`)} ${chalk.cyan(result.name)}\n`,
+		);
+		disableRaw();
+		return { lat: result.lat, lon: result.lon, name: result.name };
+	};
+
+	await draw();
+
+	while (true) {
+		const key = await readKey();
+
+		if (key[0] === 3) {
+			await clearLines(prevLines);
+			await write("\n");
+			disableRaw();
+			process.exit(0);
+		}
+
+		if (key[0] === 13) {
+			const current = suggestions[selected];
+			if (suggestions.length > 0 && current) {
+				return finish(current);
+			}
+			if (input.length >= MIN_QUERY_LEN && suggestions.length === 0) {
+				try {
+					const results = await geocode(input);
+					suggestions = dedupeResults(results, MAX_SUGGESTIONS);
+					selected = 0;
+					const first = suggestions[0];
+					if (suggestions.length === 1 && first) return finish(first);
+					await draw();
+				} catch {}
+			}
+			continue;
+		}
+
+		if (key[0] === 9) {
+			const current = suggestions[selected];
+			if (suggestions.length > 0 && current) {
+				input = current.name;
+				scheduleSearch();
+				await draw();
+			}
+			continue;
+		}
+
+		if (key[0] === 127 || key[0] === 8) {
+			if (input.length > 0) {
+				input = input.slice(0, -1);
+				scheduleSearch();
+				await draw();
+			}
+			continue;
+		}
+
+		if (key[0] === 27 && key[1] === 91) {
+			if (key[2] === 65 && suggestions.length > 0) {
+				selected = (selected - 1 + suggestions.length) % suggestions.length;
+				await draw();
+			}
+			if (key[2] === 66 && suggestions.length > 0) {
+				selected = (selected + 1) % suggestions.length;
+				await draw();
+			}
+			continue;
+		}
+
+		if (key[0] === 27 || (key[0] !== undefined && key[0] < 32)) continue;
+
+		input += key.toString("utf-8");
+		scheduleSearch();
+		await draw();
+	}
+}
+
+// --- Time mode prompt ---
+
+export interface TimeMode {
+	time: string;
+	arrivalBy: boolean;
+}
+
+export async function promptTimeMode(): Promise<TimeMode> {
+	enableRaw();
+
+	const options = [
+		{ label: "Leave now", time: currentTime(), needsInput: false, arrivalBy: false },
+		{ label: "Depart at…", time: "", needsInput: true, arrivalBy: false },
+		{ label: "Arrive by…", time: "", needsInput: true, arrivalBy: true },
+	];
+
+	let selected = 0;
+
+	const draw = async () => {
+		let buf = `${ANSI.carriageReturn}${ANSI.clearLine}${chalk.bold("When:")}`;
+		for (let i = 0; i < options.length; i++) {
+			const opt = options[i];
+			if (!opt) continue;
+			if (i === selected) {
+				buf += `  ${chalk.cyan.bold(opt.label)}`;
+			} else {
+				buf += `  ${chalk.dim(opt.label)}`;
+			}
+		}
+		buf += chalk.dim("  ←/→ to pick, enter to confirm");
+		await write(buf);
+	};
+
+	await draw();
+
+	while (true) {
+		const key = await readKey();
+
+		if (key[0] === 3) {
+			await write("\n");
+			disableRaw();
+			process.exit(0);
+		}
+
+		// Enter
+		if (key[0] === 13) {
+			const opt = options[selected];
+			if (!opt) continue;
+			if (!opt.needsInput) {
+				await write(
+					`${ANSI.carriageReturn}${ANSI.clearLine}${chalk.bold("When:")} ${chalk.cyan(opt.label)}\n`,
+				);
+				disableRaw();
+				return { time: opt.time, arrivalBy: opt.arrivalBy };
+			}
+
+			// Need time input
+			await write(
+				`${ANSI.carriageReturn}${ANSI.clearLine}${chalk.bold(opt.label.replace("…", ":"))} `,
+			);
+			disableRaw();
+
+			const timeInput = (prompt("") ?? "").trim();
+			if (/^\d{1,2}:\d{2}$/.test(timeInput)) {
+				return { time: timeInput, arrivalBy: opt.arrivalBy };
+			}
+			// Invalid, re-prompt
+			enableRaw();
+			await draw();
+			continue;
+		}
+
+		// Left/Right arrows
+		if (key[0] === 27 && key[1] === 91) {
+			if (key[2] === 68) selected = (selected - 1 + options.length) % options.length; // Left
+			if (key[2] === 67) selected = (selected + 1) % options.length; // Right
+			await draw();
+			continue;
+		}
+
+		// Tab cycles right
+		if (key[0] === 9) {
+			selected = (selected + 1) % options.length;
+			await draw();
+		}
+	}
+}

package/src/terminal.ts

@@ -0,0 +1,44 @@
+const ANSI = {
+	clearLine: "\x1B[K",
+	hideCursor: "\x1B[?25l",
+	showCursor: "\x1B[?25h",
+	moveUp: (n: number) => `\x1B[${n}A`,
+	moveToCol: (col: number) => `\x1B[${col}C`,
+	carriageReturn: "\r",
+	moveToStart: (n: number) => `\x1B[${n}A\x1B[G`,
+};
+
+export { ANSI };
+
+export const write = (s: string) => Bun.write(Bun.stdout, s);
+export const writeLn = (s: string) => Bun.write(Bun.stdout, `${s}\n`);
+export const writeErr = (s: string) => Bun.write(Bun.stderr, `${s}\n`);
+
+export async function clearLines(count: number) {
+	if (count > 0) {
+		let buf = "";
+		for (let i = 0; i < count; i++) buf += `\n${ANSI.clearLine}`;
+		buf += ANSI.moveUp(count);
+		await write(buf);
+	}
+}
+
+export function enableRaw() {
+	if (process.stdin.isTTY) process.stdin.setRawMode(true);
+	process.stdin.resume();
+}
+
+export function disableRaw() {
+	if (process.stdin.isTTY) process.stdin.setRawMode(false);
+	process.stdin.pause();
+}
+
+export function readKey(): Promise<Buffer> {
+	return new Promise((resolve) => {
+		const onData = (chunk: Buffer) => {
+			process.stdin.removeListener("data", onData);
+			resolve(chunk);
+		};
+		process.stdin.on("data", onData);
+	});
+}