straeto 0.1.0

package/README.md

@@ -0,0 +1,84 @@
+<p align="center">
+  <img src="icon.png" width="120" alt="Strætó logo" />
+</p>
+
+<h1 align="center">straeto</h1>
+
+<p align="center">
+  A CLI for the Icelandic bus system <a href="https://www.straeto.is">Strætó</a>, built with <a href="https://bun.sh">Bun</a>.
+</p>
+
+---
+
+## Install
+
+```bash
+bun install -g straeto
+```
+
+## Commands
+
+### `straeto route <number> [bus]`
+
+Show all active buses on a route, or drill into a specific bus by letter.
+
+```bash
+straeto route 3        # overview of all buses on route 3
+straeto route 3 A      # detail view for bus 3-A (next stops, ETA)
+straeto route 3 --watch  # live-track with a spinner, polls every second
+```
+
+### `straeto stops`
+
+List bus stops with optional filtering.
+
+```bash
+straeto stops                    # first 10 stops
+straeto stops -r 6               # stops on route 6
+straeto stops -s Hlemmur          # search by name
+straeto stops --all               # show all stops
+straeto stops -n 20              # show 20 results
+```
+
+### `straeto stop <name or id>`
+
+Look up a specific stop by name or numeric ID.
+
+```bash
+straeto stop Hlemmur
+straeto stop 10000802
+```
+
+### `straeto alerts`
+
+Show active service alerts.
+
+```bash
+straeto alerts            # alerts in Icelandic (default)
+straeto alerts -l EN      # alerts in English
+```
+
+### `straeto plan`
+
+Plan a trip between two locations. Launches interactive mode by default with autocomplete search and time selection.
+
+```bash
+straeto plan                              # interactive mode
+straeto plan -f 64.14,-21.90 -t 64.10,-21.94   # coordinate mode
+straeto plan --at 08:30                   # depart at specific time
+straeto plan --by 17:00                   # arrive by specific time
+```
+
+## Development
+
+```bash
+bun install
+bun run start           # run the CLI
+bun run lint            # check with biome
+bun run lint:fix        # auto-fix lint issues
+bun run format          # format source files
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "straeto",
+  "version": "0.1.0",
+  "description": "Strætó — Icelandic bus system CLI",
+  "author": "magtastic",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/magtastic/straeto-cli"
+  },
+  "keywords": ["straeto", "iceland", "bus", "cli", "bun", "reykjavik"],
+  "module": "src/cli.ts",
+  "type": "module",
+  "bin": {
+    "straeto": "src/cli.ts"
+  },
+  "files": ["src", "icon.png", "README.md"],
+  "scripts": {
+    "start": "bun run src/cli.ts",
+    "lint": "biome check src",
+    "lint:fix": "biome check --write src",
+    "format": "biome format --write src",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.4.6",
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "chalk": "5",
+    "commander": "13",
+    "zod": "^4.3.6"
+  }
+}

package/src/api.test.ts

@@ -0,0 +1,285 @@
+import { describe, expect, test } from "bun:test";
+import * as api from "./api";
+
+describe("getBusLocations", () => {
+	test("returns valid bus locations for a known route", async () => {
+		const data = await api.getBusLocations(["1"]);
+
+		expect(data.lastUpdate).toBeString();
+		expect(Array.isArray(data.results)).toBe(true);
+
+		for (const bus of data.results) {
+			expect(bus.busId).toBeString();
+			expect(bus.routeNr).toBe("1");
+			expect(bus.headsign).toBeString();
+			expect(bus.lat).toBeNumber();
+			expect(bus.lng).toBeNumber();
+			expect(bus.direction).toBeNumber();
+			expect(Array.isArray(bus.nextStops)).toBe(true);
+
+			for (const nextStop of bus.nextStops) {
+				expect(nextStop.arrival).toBeString();
+				expect(nextStop.waitingTime).toBeNumber();
+				if (nextStop.stop !== null) {
+					expect(nextStop.stop.name).toBeString();
+				}
+			}
+		}
+	});
+
+	test("returns empty results for nonexistent route", async () => {
+		const data = await api.getBusLocations(["99999"]);
+
+		expect(data.lastUpdate).toBeString();
+		expect(data.results).toEqual([]);
+	});
+});
+
+describe("getStops", () => {
+	test("returns a list of stops with required fields", async () => {
+		const stops = await api.getStops();
+
+		expect(stops.length).toBeGreaterThan(100);
+
+		const stop = stops[0];
+		expect(stop).toBeDefined();
+		if (!stop) return;
+
+		expect(stop.id).toBeNumber();
+		expect(stop.name).toBeString();
+		expect(stop.lat).toBeNumber();
+		expect(stop.lon).toBeNumber();
+		expect(stop.type).toBeNumber();
+		expect(stop.code === null || typeof stop.code === "string").toBe(true);
+		expect(typeof stop.isTerminal).toBe("boolean");
+		expect(Array.isArray(stop.routes)).toBe(true);
+	});
+
+	test("contains known stops", async () => {
+		const stops = await api.getStops();
+		const names = stops.map((stop) => stop.name);
+
+		expect(names).toContain("Hamraborg");
+		expect(names).toContain("Mjódd A");
+	});
+});
+
+describe("getStop", () => {
+	test("returns details for a known stop", async () => {
+		const stops = await api.getStops();
+		const hamraborg = stops.find((stop) => stop.name === "Hamraborg");
+		expect(hamraborg).toBeDefined();
+		if (!hamraborg) return;
+
+		const stop = await api.getStop(String(hamraborg.id));
+		expect(stop).not.toBeNull();
+		if (!stop) return;
+
+		expect(stop.name).toBe("Hamraborg");
+		expect(stop.lat).toBeNumber();
+		expect(stop.lon).toBeNumber();
+		expect(Array.isArray(stop.routes)).toBe(true);
+		expect(Array.isArray(stop.routes)).toBe(true);
+	});
+
+	test("returns null for nonexistent stop", async () => {
+		const stop = await api.getStop("0");
+		expect(stop).toBeNull();
+	});
+});
+
+describe("getAlerts", () => {
+	test("returns alerts in Icelandic", async () => {
+		const alerts = await api.getAlerts("IS");
+
+		expect(Array.isArray(alerts)).toBe(true);
+
+		for (const alert of alerts) {
+			expect(alert.id).toBeString();
+			expect(alert.cause).toBeString();
+			expect(alert.effect).toBeString();
+			expect(alert.title).toBeString();
+			expect(alert.text).toBeString();
+			expect(alert.dateStart).toBeString();
+			expect(Array.isArray(alert.routes)).toBe(true);
+		}
+	});
+
+	test("returns alerts in English", async () => {
+		const alerts = await api.getAlerts("EN");
+		expect(Array.isArray(alerts)).toBe(true);
+	});
+});
+
+describe("geocode", () => {
+	test("finds results for a known location", async () => {
+		const results = await api.geocode("Hlemmur");
+
+		expect(results.length).toBeGreaterThan(0);
+
+		const first = results[0];
+		expect(first).toBeDefined();
+		if (!first) return;
+
+		expect(first.id).toBeString();
+		expect(first.name).toBeString();
+		expect(first.lat).toBeNumber();
+		expect(first.lon).toBeNumber();
+		expect(first.address).toBeString();
+		expect(first.type).toBeString();
+		expect(first.subType).toBeString();
+	});
+
+	test("returns empty for gibberish query", async () => {
+		const results = await api.geocode("xyzxyzxyz123456");
+		expect(results).toEqual([]);
+	});
+});
+
+describe("planTrip", () => {
+	test("plans a trip between two known locations", async () => {
+		// Hlemmur → Mjódd (common route)
+		const trips = await api.planTrip({
+			from: "64.1426,-21.9009",
+			to: "64.1117,-21.8437",
+			date: new Date().toISOString().slice(0, 10),
+			time: "08:00",
+			arrivalBy: false,
+		});
+
+		expect(trips.length).toBeGreaterThan(0);
+
+		const trip = trips[0];
+		expect(trip).toBeDefined();
+		if (!trip) return;
+
+		expect(trip.id).toBeString();
+		expect(trip.duration.total).toBeNumber();
+		expect(trip.duration.walk).toBeNumber();
+		expect(trip.duration.bus).toBeNumber();
+		expect(trip.time.from).toBeString();
+		expect(trip.time.to).toBeString();
+		expect(trip.legs.length).toBeGreaterThan(0);
+
+		for (const leg of trip.legs) {
+			expect(["WALK", "BUS"]).toContain(leg.type);
+			expect(leg.duration).toBeNumber();
+			expect(leg.distance).toBeNumber();
+			expect(leg.time.from).toBeString();
+			expect(leg.time.to).toBeString();
+			expect(leg.from.lat).toBeNumber();
+			expect(leg.from.lon).toBeNumber();
+			expect(leg.to.lat).toBeNumber();
+			expect(leg.to.lon).toBeNumber();
+
+			if (leg.type === "BUS") {
+				expect(leg.trip).toBeDefined();
+				expect(leg.trip?.routeNr).toBeString();
+				expect(leg.trip?.headsign).toBeString();
+			}
+		}
+	});
+});
+
+describe("findBus", () => {
+	test("finds a bus by route and letter", () => {
+		const buses: api.BusLocation[] = [
+			{
+				busId: "1-A",
+				tripId: "t1",
+				routeNr: "3",
+				tag: null,
+				headsign: "Grandi",
+				lat: 64.0,
+				lng: -21.0,
+				direction: 0,
+				nextStops: [],
+			},
+			{
+				busId: "2-B",
+				tripId: "t2",
+				routeNr: "3",
+				tag: null,
+				headsign: "Sel/Fell",
+				lat: 64.1,
+				lng: -21.1,
+				direction: 180,
+				nextStops: [],
+			},
+		];
+
+		const found = api.findBus(buses, "3", "b");
+		expect(found).toBeDefined();
+		expect(found?.busId).toBe("2-B");
+
+		expect(api.findBus(buses, "3", "c")).toBeUndefined();
+		expect(api.findBus(buses, "5", "a")).toBeUndefined();
+	});
+});
+
+describe("findLastStop", () => {
+	test("returns closest stop not in nextStops", () => {
+		const bus: api.BusLocation = {
+			busId: "1-A",
+			tripId: "t1",
+			routeNr: "3",
+			tag: null,
+			headsign: "Grandi",
+			lat: 64.15,
+			lng: -21.95,
+			direction: 0,
+			nextStops: [{ arrival: "", waitingTime: 2, stop: { name: "NextStop" } }],
+		};
+
+		const stops: api.Stop[] = [
+			{
+				id: 1,
+				name: "NextStop",
+				lat: 64.16,
+				lon: -21.96,
+				type: 1,
+				code: null,
+				isTerminal: false,
+				routes: ["3"],
+			},
+			{
+				id: 2,
+				name: "PreviousStop",
+				lat: 64.149,
+				lon: -21.949,
+				type: 1,
+				code: null,
+				isTerminal: false,
+				routes: ["3"],
+			},
+			{
+				id: 3,
+				name: "FarStop",
+				lat: 64.2,
+				lon: -22.0,
+				type: 1,
+				code: null,
+				isTerminal: false,
+				routes: ["3"],
+			},
+		];
+
+		expect(api.findLastStop(bus, stops)).toBe("PreviousStop");
+	});
+
+	test("returns undefined when no route stops exist", () => {
+		const bus: api.BusLocation = {
+			busId: "1-A",
+			tripId: "t1",
+			routeNr: "99",
+			tag: null,
+			headsign: "Nowhere",
+			lat: 64.0,
+			lng: -21.0,
+			direction: 0,
+			nextStops: [],
+		};
+
+		expect(api.findLastStop(bus, [])).toBeUndefined();
+	});
+});

package/src/api.ts

@@ -0,0 +1,302 @@
+import { z } from "zod/v4";
+import { currentDate } from "./format";
+
+const API_URL = "https://api.straeto.is/graphql";
+
+const HEADERS = {
+	"Content-Type": "application/json",
+	Origin: "https://www.straeto.is",
+};
+
+async function query<T>(
+	gql: string,
+	variables: Record<string, unknown> | undefined,
+	schema: z.ZodType<T>,
+): Promise<T> {
+	const res = await fetch(API_URL, {
+		method: "POST",
+		headers: HEADERS,
+		body: JSON.stringify({ query: gql, variables }),
+	});
+
+	if (!res.ok) throw new Error(`API error: ${res.status}`);
+
+	const json = (await res.json()) as { data?: unknown; errors?: { message: string }[] };
+	if (json.errors && !json.data)
+		throw new Error(json.errors.map((error) => error.message).join(", "));
+	if (!json.data) throw new Error("No data returned from API");
+	return schema.parse(json.data);
+}
+
+// --- Schemas ---
+
+const NextStopSchema = z.object({
+	arrival: z.string(),
+	waitingTime: z.number(),
+	stop: z.object({ name: z.string() }).nullable(),
+});
+
+const BusLocationSchema = z.object({
+	busId: z.string(),
+	tripId: z.string(),
+	routeNr: z.string(),
+	tag: z.string().nullable(),
+	headsign: z.string(),
+	lat: z.number(),
+	lng: z.number(),
+	direction: z.number(),
+	nextStops: z.array(NextStopSchema),
+});
+
+const StopSchema = z.object({
+	id: z.number(),
+	name: z.string(),
+	lat: z.number(),
+	lon: z.number(),
+	type: z.number(),
+	code: z.string().nullable(),
+	isTerminal: z.boolean(),
+	routes: z.array(z.string()),
+});
+
+const AlertSchema = z.object({
+	id: z.string(),
+	cause: z.string(),
+	effect: z.string(),
+	routes: z.array(z.string()),
+	title: z.string(),
+	text: z.string(),
+	dateStart: z.string(),
+	dateEnd: z.string().nullable(),
+});
+
+const GeoResultSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	lat: z.number(),
+	lon: z.number(),
+	address: z.string(),
+	type: z.string(),
+	subType: z.string(),
+});
+
+const TripStopSchema = z.object({
+	id: z.union([z.string(), z.number()]),
+	name: z.string(),
+	lat: z.number(),
+	lon: z.number(),
+});
+
+const TripLegSchema = z.object({
+	type: z.string(),
+	duration: z.number(),
+	distance: z.number(),
+	time: z.object({ from: z.string(), to: z.string() }),
+	from: z.object({
+		lat: z.number(),
+		lon: z.number(),
+		depature: z.string().nullable(),
+		stop: TripStopSchema.nullable(),
+	}),
+	to: z.object({
+		lat: z.number(),
+		lon: z.number(),
+		arrival: z.string().nullable(),
+		stop: TripStopSchema.nullable(),
+	}),
+	trip: z.object({ routeNr: z.string(), headsign: z.string() }).optional(),
+	stops: z.array(z.object({ id: z.union([z.string(), z.number()]), name: z.string() })).optional(),
+});
+
+const TripItinerarySchema = z.object({
+	id: z.string(),
+	duration: z.object({ walk: z.number(), bus: z.number(), total: z.number() }),
+	time: z.object({ from: z.string(), to: z.string() }),
+	legs: z.array(TripLegSchema),
+});
+
+// --- Exported types ---
+
+export type NextStop = z.infer<typeof NextStopSchema>;
+export type BusLocation = z.infer<typeof BusLocationSchema>;
+export type Stop = z.infer<typeof StopSchema>;
+export type Alert = z.infer<typeof AlertSchema>;
+export type GeoResult = z.infer<typeof GeoResultSchema>;
+export type TripStop = z.infer<typeof TripStopSchema>;
+export type TripLeg = z.infer<typeof TripLegSchema>;
+export type TripItinerary = z.infer<typeof TripItinerarySchema>;
+export type StopDetail = z.infer<typeof StopDetailSchema>;
+
+// --- Helpers ---
+
+function distSq(lat1: number, lon1: number, lat2: number, lon2: number) {
+	return (lat1 - lat2) ** 2 + (lon1 - lon2) ** 2;
+}
+
+export function findBus(buses: BusLocation[], route: string, letter: string) {
+	const upper = letter.toUpperCase();
+	return buses.find((bus) => {
+		const busLetter = bus.busId.split("-").pop()?.toUpperCase();
+		return bus.routeNr === route && busLetter === upper;
+	});
+}
+
+export function findLastStop(bus: BusLocation, stops: Stop[]): string | undefined {
+	const nextNames = new Set(
+		bus.nextStops.filter((nextStop) => nextStop.stop).map((nextStop) => nextStop.stop?.name),
+	);
+	const routeStops = stops.filter(
+		(stop) => stop.routes.includes(bus.routeNr) && !nextNames.has(stop.name),
+	);
+	const first = routeStops[0];
+	if (!first) return undefined;
+	// Find closest to bus position (note: BusLocation uses lng, Stop uses lon)
+	let closest = first;
+	let minDist = distSq(bus.lat, bus.lng, closest.lat, closest.lon);
+	for (let i = 1; i < routeStops.length; i++) {
+		const stop = routeStops[i];
+		if (!stop) continue;
+		const dist = distSq(bus.lat, bus.lng, stop.lat, stop.lon);
+		if (dist < minDist) {
+			minDist = dist;
+			closest = stop;
+		}
+	}
+	return closest.name;
+}
+
+// --- Response schemas ---
+
+const BusLocationResponseSchema = z.object({
+	BusLocationByRoute: z.object({
+		lastUpdate: z.string(),
+		results: z.array(BusLocationSchema),
+	}),
+});
+
+const StopsResponseSchema = z.object({
+	GtfsStops: z.object({ results: z.array(StopSchema) }),
+});
+
+const StopDetailSchema = StopSchema.extend({
+	streetView: z.object({ iframeUrl: z.string() }).nullable(),
+});
+
+const StopResponseSchema = z.object({
+	GtfsStop: StopDetailSchema.nullable(),
+});
+
+const AlertsResponseSchema = z.object({
+	Alerts: z.object({ results: z.array(AlertSchema) }),
+});
+
+const GeocodeResponseSchema = z.object({
+	Geocode: z.object({ results: z.array(GeoResultSchema) }),
+});
+
+const TripPlannerResponseSchema = z.object({
+	TripPlanner: z.object({ results: z.array(TripItinerarySchema) }),
+});
+
+// --- Queries ---
+
+export async function getBusLocations(routes: string[]) {
+	const data = await query(
+		`query BusLocationByRoute($routes: [String!]!) {
+      BusLocationByRoute(routes: $routes) {
+        lastUpdate
+        results {
+          busId tripId routeNr tag headsign lat lng direction
+          nextStops { arrival waitingTime stop { name } }
+        }
+      }
+    }`,
+		{ routes },
+		BusLocationResponseSchema,
+	);
+	return data.BusLocationByRoute;
+}
+
+export async function getStops() {
+	const data = await query(
+		`{ GtfsStops { results { id name lat lon type code isTerminal routes } } }`,
+		undefined,
+		StopsResponseSchema,
+	);
+	return data.GtfsStops.results;
+}
+
+export async function getStop(id: string) {
+	const today = currentDate();
+	const data = await query(
+		`query Stop($id: String!, $date: String) {
+      GtfsStop(id: $id, date: $date) {
+        id name lat lon type code isTerminal routes
+        streetView { iframeUrl }
+      }
+    }`,
+		{ id, date: today },
+		StopResponseSchema,
+	);
+	return data.GtfsStop;
+}
+
+export async function getAlerts(language: string = "IS") {
+	const data = await query(
+		`query Alerts($language: AlertLanguage) {
+      Alerts(language: $language) {
+        results { id cause effect routes title text dateStart dateEnd }
+      }
+    }`,
+		{ language },
+		AlertsResponseSchema,
+	);
+	return data.Alerts.results;
+}
+
+export async function geocode(placesQuery: string) {
+	const data = await query(
+		`query Geocode($placesQuery: String!) {
+      Geocode(query: $placesQuery) {
+        results { id name lat lon address type subType }
+      }
+    }`,
+		{ placesQuery },
+		GeocodeResponseSchema,
+	);
+	return data.Geocode.results;
+}
+
+export async function planTrip(opts: {
+	from: string;
+	to: string;
+	date: string;
+	time: string;
+	arrivalBy?: boolean;
+}) {
+	const data = await query(
+		`query TripPlanner($time: String!, $date: String!, $from: String!, $to: String!, $arrivalBy: Boolean, $language: Language) {
+      TripPlanner(time: $time, date: $date, from: $from, to: $to, arrivalBy: $arrivalBy, language: $language) {
+        id
+        results {
+          id
+          duration { walk bus total }
+          time { from to }
+          legs {
+            type duration distance
+            time { from to }
+            stops { id name }
+            from { lon lat depature stop { id name lat lon } }
+            to { lon lat arrival stop { id name lat lon } }
+            ... on TripPlannerLegBus {
+              trip { routeNr headsign }
+            }
+          }
+        }
+      }
+    }`,
+		opts,
+		TripPlannerResponseSchema,
+	);
+	return data.TripPlanner.results;
+}