straeto 0.1.4 → 0.1.7

package/README.md

@@ -11,7 +11,6 @@
 <p align="center">
   <a href="https://www.npmjs.com/package/straeto"><img src="https://img.shields.io/npm/v/straeto" alt="npm version" /></a>
   <a href="https://github.com/magtastic/straeto-cli/actions/workflows/ci.yml"><img src="https://github.com/magtastic/straeto-cli/actions/workflows/ci.yml/badge.svg" alt="CI" /></a>
-  <a href="https://www.npmjs.com/package/straeto"><img src="https://img.shields.io/npm/dm/straeto" alt="npm downloads" /></a>
   <a href="https://github.com/magtastic/straeto-cli/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/straeto" alt="license" /></a>
 </p>
 
@@ -63,6 +62,15 @@ straeto stop Hlemmur
 straeto stop 10000802
 ```
 
+### `straeto search [query]`
+
+Search for a place by name. Launches interactive mode with autocomplete if no query is provided.
+
+```bash
+straeto search Höfðatorg            # search by name
+straeto search                      # interactive with autocomplete
+```
+
 ### `straeto alerts`
 
 Show active service alerts.
@@ -72,17 +80,40 @@ straeto alerts            # alerts in Icelandic (default)
 straeto alerts -l EN      # alerts in English
 ```
 
+### `straeto next <stop>`
+
+Show real-time upcoming arrivals at a stop.
+
+```bash
+straeto next Höfðatorg               # all upcoming arrivals
+straeto next Höfðatorg -r 14         # only route 14
+straeto next Höfðatorg -d Grandi     # filter by direction
+straeto next Höfðatorg -r 14 -n 3   # limit to 3 results
+```
+
 ### `straeto plan`
 
-Plan a trip between two locations. Launches interactive mode by default with autocomplete search and time selection.
+Plan a trip between two locations. Accepts place names or coordinates. 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 -f Höfðatorg -t Mýrargata    # place names
+straeto plan -f 64.14,-21.90 -t 64.10,-21.94   # coordinates
 straeto plan --at 08:30                   # depart at specific time
 straeto plan --by 17:00                   # arrive by specific time
 ```
 
+## Claude Code Plugin
+
+Use Strætó directly inside [Claude Code](https://docs.anthropic.com/en/docs/claude-code) — ask about bus routes, stops, alerts, or plan trips in natural language.
+
+```
+/plugin marketplace add magtastic/straeto-cli
+/plugin install straeto@straeto
+```
+
+Then type `/straeto` or just ask about buses in Reykjavík.
+
 ## Development
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "straeto",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "description": "Strætó — Icelandic bus system CLI",
   "author": "magtastic",
   "license": "MIT",

package/src/api.ts

@@ -8,24 +8,65 @@ const HEADERS = {
 	Origin: "https://www.straeto.is",
 };
 
+const MAX_RETRIES = 3;
+const TIMEOUT_MS = 5000;
+
 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 }),
-	});
+	const start = Date.now();
+
+	for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+		if (Date.now() - start > TIMEOUT_MS) break;
+
+		if (attempt > 0) {
+			const delay = 200 * 2 ** (attempt - 1);
+			const remaining = TIMEOUT_MS - (Date.now() - start);
+			if (remaining <= 0) break;
+			await new Promise((r) => setTimeout(r, Math.min(delay, remaining)));
+		}
 
-	if (!res.ok) throw new Error(`API error: ${res.status}`);
+		try {
+			const res = await fetch(API_URL, {
+				method: "POST",
+				headers: HEADERS,
+				body: JSON.stringify({ query: gql, variables }),
+				signal: AbortSignal.timeout(TIMEOUT_MS - (Date.now() - start)),
+			});
+
+			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");
+
+			const result = schema.safeParse(json.data);
+			if (!result.success) {
+				const issues = result.error.issues
+					.map((i) => `  ${i.path.join(".")}: ${i.message}`)
+					.join("\n");
+				const firstPath = result.error.issues[0]?.path ?? [];
+				let sample: unknown = json.data;
+				for (const key of firstPath) {
+					if (sample != null && typeof sample === "object")
+						sample = (sample as Record<string | number, unknown>)[key as string | number];
+				}
+				const raw = JSON.stringify(sample, null, 2);
+				const preview = raw && raw.length > 500 ? `${raw.slice(0, 500)}…` : raw;
+				throw new Error(
+					`Schema validation failed:\n${issues}\n\nValue at "${firstPath.join(".")}":\n${preview}`,
+				);
+			}
+			return result.data;
+		} catch (err) {
+			if (attempt === MAX_RETRIES - 1 || Date.now() - start > TIMEOUT_MS) throw err;
+		}
+	}
 
-	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);
+	throw new Error("Strætó is not responding — please try again in a moment.");
 }
 
 // --- Schemas ---
@@ -168,14 +209,16 @@ export function findLastStop(bus: BusLocation, stops: Stop[]): string | undefine
 // --- Response schemas ---
 
 const BusLocationResponseSchema = z.object({
-	BusLocationByRoute: z.object({
-		lastUpdate: z.string(),
-		results: z.array(BusLocationSchema),
-	}),
+	BusLocationByRoute: z
+		.object({
+			lastUpdate: z.string(),
+			results: z.array(BusLocationSchema),
+		})
+		.nullable(),
 });
 
 const StopsResponseSchema = z.object({
-	GtfsStops: z.object({ results: z.array(StopSchema) }),
+	GtfsStops: z.object({ results: z.array(StopSchema) }).nullable(),
 });
 
 const StopDetailSchema = StopSchema.extend({
@@ -187,15 +230,15 @@ const StopResponseSchema = z.object({
 });
 
 const AlertsResponseSchema = z.object({
-	Alerts: z.object({ results: z.array(AlertSchema) }),
+	Alerts: z.object({ results: z.array(AlertSchema) }).nullable(),
 });
 
 const GeocodeResponseSchema = z.object({
-	Geocode: z.object({ results: z.array(GeoResultSchema) }),
+	Geocode: z.object({ results: z.array(GeoResultSchema) }).nullable(),
 });
 
 const TripPlannerResponseSchema = z.object({
-	TripPlanner: z.object({ results: z.array(TripItinerarySchema) }),
+	TripPlanner: z.object({ results: z.array(TripItinerarySchema) }).nullable(),
 });
 
 // --- Queries ---
@@ -214,7 +257,7 @@ export async function getBusLocations(routes: string[]) {
 		{ routes },
 		BusLocationResponseSchema,
 	);
-	return data.BusLocationByRoute;
+	return data.BusLocationByRoute ?? { lastUpdate: "", results: [] };
 }
 
 export async function getStops() {
@@ -223,7 +266,7 @@ export async function getStops() {
 		undefined,
 		StopsResponseSchema,
 	);
-	return data.GtfsStops.results;
+	return data.GtfsStops?.results ?? [];
 }
 
 export async function getStop(id: string) {
@@ -251,7 +294,7 @@ export async function getAlerts(language: string = "IS") {
 		{ language },
 		AlertsResponseSchema,
 	);
-	return data.Alerts.results;
+	return data.Alerts?.results ?? [];
 }
 
 export async function geocode(placesQuery: string) {
@@ -264,7 +307,7 @@ export async function geocode(placesQuery: string) {
 		{ placesQuery },
 		GeocodeResponseSchema,
 	);
-	return data.Geocode.results;
+	return data.Geocode?.results ?? [];
 }
 
 export async function planTrip(opts: {
@@ -298,5 +341,5 @@ export async function planTrip(opts: {
 		opts,
 		TripPlannerResponseSchema,
 	);
-	return data.TripPlanner.results;
+	return data.TripPlanner?.results ?? [];
 }

package/src/cli.test.ts

@@ -26,6 +26,8 @@ describe("cli --help", () => {
 		expect(stdout).toContain("route");
 		expect(stdout).toContain("stops");
 		expect(stdout).toContain("stop");
+		expect(stdout).toContain("search");
+		expect(stdout).toContain("next");
 		expect(stdout).toContain("alerts");
 		expect(stdout).toContain("plan");
 	});
@@ -70,6 +72,30 @@ describe("cli route (help/args)", () => {
 	});
 });
 
+describe("cli search (help/args)", () => {
+	test("shows help for search command", async () => {
+		const { stdout, exitCode } = await run("search", "--help");
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("--interactive");
+	});
+});
+
+describe("cli next (help/args)", () => {
+	test("shows help for next command", async () => {
+		const { stdout, exitCode } = await run("next", "--help");
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("--route");
+		expect(stdout).toContain("--direction");
+		expect(stdout).toContain("--limit");
+	});
+
+	test("fails without stop argument", async () => {
+		const { stderr, exitCode } = await run("next");
+		expect(exitCode).toBe(1);
+		expect(stderr).toContain("missing required argument");
+	});
+});
+
 describe("cli plan (help/args)", () => {
 	test("shows help for plan command", async () => {
 		const { stdout, exitCode } = await run("plan", "--help");

package/src/cli.ts

@@ -3,9 +3,11 @@ import chalk from "chalk";
 import { program } from "commander";
 import pkg from "../package.json";
 import { alertsCommand } from "./commands/alerts";
+import { nextCommand } from "./commands/next";
 import { planCommand } from "./commands/plan";
 import { routeCommand } from "./commands/route";
-import { AlertsOpts, PlanOpts, RouteOpts, StopsOpts } from "./commands/schemas";
+import { AlertsOpts, NextOpts, PlanOpts, RouteOpts, StopsOpts } from "./commands/schemas";
+import { searchCommand } from "./commands/search";
 import { stopCommand } from "./commands/stop";
 import { stopsCommand } from "./commands/stops";
 import { writeErr } from "./terminal";
@@ -75,11 +77,39 @@ program
 		}
 	});
 
+program
+	.command("search")
+	.description("Search for a place by name")
+	.argument("[query...]", "Place name to search for")
+	.option("-i, --interactive", "Interactive mode with autocomplete")
+	.action(async (parts: string[], rawOpts: { interactive?: boolean }) => {
+		try {
+			await searchCommand(parts, !!rawOpts.interactive || parts.length === 0);
+		} catch (error) {
+			handleError(error);
+		}
+	});
+
+program
+	.command("next")
+	.description("Show upcoming arrivals at a stop")
+	.argument("<stop...>", "Stop name or ID")
+	.option("-r, --route <route>", "Filter by route number")
+	.option("-d, --direction <headsign>", "Filter by direction/headsign")
+	.option("-n, --limit <n>", "Limit results")
+	.action(async (parts: string[], rawOpts) => {
+		try {
+			await nextCommand(parts, NextOpts.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("-f, --from <place>", "Origin as place name or lat,lon")
+	.option("-t, --to <place>", "Destination as place name or 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)")

package/src/commands/next.ts

@@ -0,0 +1,86 @@
+import chalk from "chalk";
+import type { z } from "zod/v4";
+import * as api from "../api";
+import { writeLn } from "../terminal";
+import type { NextOpts } from "./schemas";
+
+interface Arrival {
+	routeNr: string;
+	headsign: string;
+	busId: string;
+	waitingTime: number;
+	stopsAway: number;
+}
+
+export async function nextCommand(parts: string[], opts: z.infer<typeof NextOpts>) {
+	const input = parts.join(" ");
+	const stops = await api.getStops();
+	const query = input.toLowerCase();
+
+	// Find matching stops
+	let matches = stops.filter((s) => s.name.toLowerCase() === query);
+	if (matches.length === 0) {
+		matches = stops.filter((s) => s.name.toLowerCase().includes(query));
+	}
+	if (matches.length === 0) throw new Error(`No stops matching "${input}".`);
+
+	// Collect all route numbers serving matched stops
+	const stopNames = new Set(matches.map((s) => s.name.toLowerCase()));
+	const allRoutes = [...new Set(matches.flatMap((s) => s.routes))];
+
+	// Filter by route if specified
+	const routes = opts.route ? allRoutes.filter((r) => r === opts.route) : allRoutes;
+	if (routes.length === 0) throw new Error(`Route ${opts.route} does not serve "${input}".`);
+
+	// Fetch bus locations for all relevant routes
+	const data = await api.getBusLocations(routes);
+
+	// Find buses heading to this stop
+	const arrivals: Arrival[] = [];
+	for (const bus of data.results) {
+		for (let i = 0; i < bus.nextStops.length; i++) {
+			const nextStop = bus.nextStops[i];
+			if (!nextStop?.stop) continue;
+			if (!stopNames.has(nextStop.stop.name.toLowerCase())) continue;
+
+			// Filter by direction/headsign if specified
+			if (opts.direction) {
+				const dir = opts.direction.toLowerCase();
+				if (!bus.headsign.toLowerCase().includes(dir)) continue;
+			}
+
+			arrivals.push({
+				routeNr: bus.routeNr,
+				headsign: bus.headsign,
+				busId: bus.busId,
+				waitingTime: nextStop.waitingTime,
+				stopsAway: i + 1,
+			});
+			break;
+		}
+	}
+
+	// Sort by arrival time
+	arrivals.sort((a, b) => a.waitingTime - b.waitingTime);
+
+	const stopLabel = matches[0]?.name ?? input;
+
+	if (arrivals.length === 0) {
+		writeLn(chalk.dim(`No upcoming arrivals at ${stopLabel}.`));
+		return;
+	}
+
+	const limit = opts.limit ? parseInt(opts.limit, 10) : 10;
+	const shown = arrivals.slice(0, limit);
+
+	writeLn(`${chalk.bold.underline(stopLabel)} ${chalk.dim(`— ${arrivals.length} upcoming`)}\n`);
+
+	for (const a of shown) {
+		const route = chalk.bold.yellow(a.routeNr.padEnd(4));
+		const headsign = chalk.cyan(a.headsign.padEnd(20));
+		const time =
+			a.waitingTime <= 1 ? chalk.green.bold("< 1 mín") : chalk.green.bold(`${a.waitingTime} mín`);
+		const stops = chalk.dim(`${a.stopsAway} stop${a.stopsAway !== 1 ? "s" : ""} away`);
+		writeLn(`  ${route}${headsign}  ${time}  ${stops}`);
+	}
+}

package/src/commands/plan.ts

@@ -12,6 +12,21 @@ export async function planCommand(opts: z.infer<typeof PlanOpts>) {
 	let from = opts.from;
 	let to = opts.to;
 
+	// Geocode place names to coordinates
+	const isCoords = (s: string) => /^-?\d+\.?\d*,-?\d+\.?\d*$/.test(s);
+	if (from && !isCoords(from)) {
+		const results = await api.geocode(from);
+		if (results.length === 0) throw new Error(`Could not find location "${from}"`);
+		const loc = results[0];
+		if (loc) from = `${loc.lat},${loc.lon}`;
+	}
+	if (to && !isCoords(to)) {
+		const results = await api.geocode(to);
+		if (results.length === 0) throw new Error(`Could not find location "${to}"`);
+		const loc = results[0];
+		if (loc) to = `${loc.lat},${loc.lon}`;
+	}
+
 	if (opts.interactive || (!from && !to)) {
 		const { promptLocation, promptTimeMode } = await import("../prompt");
 		writeLn("");

package/src/commands/schemas.ts

@@ -16,6 +16,12 @@ export const AlertsOpts = z.object({
 	lang: z.string(),
 });
 
+export const NextOpts = z.object({
+	route: z.string().optional(),
+	direction: z.string().optional(),
+	limit: z.string().optional(),
+});
+
 export const PlanOpts = z.object({
 	from: z.string().optional(),
 	to: z.string().optional(),

package/src/commands/search.ts

@@ -0,0 +1,22 @@
+import * as api from "../api";
+import * as fmt from "../format";
+import { writeLn } from "../terminal";
+
+export async function searchCommand(parts: string[], interactive: boolean) {
+	if (interactive || parts.length === 0) {
+		const { promptLocation } = await import("../prompt");
+		writeLn("");
+		const result = await promptLocation("Search", api.geocode);
+		writeLn(`\n  ${result.name}  ${result.lat}, ${result.lon}`);
+		return;
+	}
+
+	const query = parts.join(" ");
+	const results = await api.geocode(query);
+	const limit = 10;
+	writeLn(fmt.formatGeocode(results.slice(0, limit)));
+	if (results.length > limit) {
+		const chalk = (await import("chalk")).default;
+		writeLn(chalk.dim(`\n  … and ${results.length - limit} more`));
+	}
+}

package/src/prompt.ts

@@ -221,7 +221,7 @@ export async function promptTimeMode(): Promise<TimeMode> {
 
 			// Need time input
 			await write(
-				`${ANSI.carriageReturn}${ANSI.clearLine}${chalk.bold(opt.label.replace("…", ":"))} `,
+				`${ANSI.carriageReturn}${ANSI.clearLine}${chalk.bold(opt.label.replace("…", ":"))} ${chalk.dim("(HH:MM) ")}`,
 			);
 			disableRaw();
 
@@ -229,7 +229,8 @@ export async function promptTimeMode(): Promise<TimeMode> {
 			if (/^\d{1,2}:\d{2}$/.test(timeInput)) {
 				return { time: timeInput, arrivalBy: opt.arrivalBy };
 			}
-			// Invalid, re-prompt
+			// Invalid, show hint and re-prompt
+			await write(chalk.yellow("  Please enter time as HH:MM (e.g. 08:30)\n"));
 			enableRaw();
 			await draw();
 			continue;