straeto 0.1.4 → 0.1.5

package/README.md

@@ -63,6 +63,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 +81,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.5",
   "description": "Strætó — Icelandic bus system CLI",
   "author": "magtastic",
   "license": "MIT",

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;