@nastechai/agent 0.16.0 → 0.17.0

package/src/lib/schedule.ts

@@ -0,0 +1,382 @@
+/**
+ * Schedule builder helpers for the cron page.
+ *
+ * The nastech-agent backend (cron/jobs.py::parse_schedule) accepts a
+ * surprisingly broad set of string formats:
+ *
+ *   - Duration (one-shot):       "30m", "2h", "1d"
+ *   - Interval (recurring):      "every 30m", "every 2h", "every 1d"
+ *   - Cron expression (5-field): "0 9 * * *", "30 14 * * 1,3,5"
+ *   - ISO timestamp (one-shot):  "2026-02-03T14:00:00"
+ *
+ * Power users can hand-type any of those, but for everyone else the
+ * dashboard now offers a human-readable picker. This module is the
+ * pure logic layer behind that picker:
+ *
+ *   - {@link buildScheduleString} turns the picker's structured state
+ *     into one of the strings above.
+ *   - {@link describeSchedule} goes the other way: takes the structured
+ *     schedule shape the API returns (``CronJob.schedule``) and produces
+ *     a human-readable sentence for the job list. It recognises common
+ *     cron-expression shapes (daily/weekly/monthly) so users don't have
+ *     to parse "30 14 * * 1,3,5" by eye.
+ *
+ * Kept dependency-free and locale-string-driven so it tree-shakes
+ * cleanly and is testable in isolation if we ever wire up vitest here.
+ */
+
+/** Picker modes — each renders a different set of inputs in the UI but
+ * all funnel through {@link buildScheduleString} to a backend-compatible
+ * string. ``custom`` is the escape hatch for power users who still want
+ * to type a raw cron expression. */
+export type ScheduleMode =
+  | "interval"
+  | "daily"
+  | "weekly"
+  | "monthly"
+  | "once"
+  | "custom";
+
+/** Unit used by interval mode. Backend parses ``m``/``h``/``d`` suffixes. */
+export type IntervalUnit = "minutes" | "hours" | "days";
+
+/** Cron weekday convention: Sunday = 0 .. Saturday = 6. Matches what
+ * croniter expects on the backend (no need to remap on submit). */
+export const WEEKDAY_INDEXES = [0, 1, 2, 3, 4, 5, 6] as const;
+export type Weekday = (typeof WEEKDAY_INDEXES)[number];
+
+export interface ScheduleBuilderState {
+  /** Index of which "custom" radio is selected. */
+  mode: ScheduleMode;
+
+  /** Interval mode: positive integer, paired with ``intervalUnit``. */
+  intervalValue: number;
+  intervalUnit: IntervalUnit;
+
+  /** Daily/weekly/monthly mode: "HH:MM" 24h format from <input type=time>. */
+  timeOfDay: string;
+
+  /** Weekly mode: 0..6, Sunday-first. Empty means "every day", which is
+   * still valid — we send "*" for the day-of-week cron field. */
+  weekdays: Weekday[];
+
+  /** Monthly mode: 1..31 (no support for "last day of month" sugar — the
+   * croniter ``L`` extension isn't enabled in the parse_schedule regex). */
+  dayOfMonth: number;
+
+  /** Once mode: ``YYYY-MM-DDTHH:MM`` from <input type=datetime-local>. */
+  onceAt: string;
+
+  /** Custom mode: raw user-typed cron expression. Stored separately so
+   * flipping between modes doesn't erase the user's work. */
+  custom: string;
+}
+
+/** Default state — "every 30 minutes" is the most-common-cron-pattern
+ * starting point and avoids forcing the user to pick everything from
+ * scratch. */
+export const DEFAULT_SCHEDULE_STATE: ScheduleBuilderState = {
+  mode: "interval",
+  intervalValue: 30,
+  intervalUnit: "minutes",
+  timeOfDay: "09:00",
+  weekdays: [1, 2, 3, 4, 5],
+  dayOfMonth: 1,
+  onceAt: "",
+  custom: "",
+};
+
+const UNIT_SUFFIX: Record<IntervalUnit, string> = {
+  minutes: "m",
+  hours: "h",
+  days: "d",
+};
+
+/** Build the schedule string from picker state. Returns ``""`` when the
+ * state is incomplete enough that the backend would 400 — the caller
+ * uses that to disable the Submit button.
+ *
+ * Why we lean on the broad parse_schedule grammar instead of always
+ * emitting cron expressions: interval syntax ("every 30m") survives a
+ * backend without ``croniter`` installed and renders more readably in
+ * the job list. We only emit raw cron when the picker truly needs the
+ * cron field expressiveness (specific weekdays, specific day-of-month). */
+export function buildScheduleString(state: ScheduleBuilderState): string {
+  switch (state.mode) {
+    case "interval": {
+      const n = Math.floor(state.intervalValue);
+      if (!Number.isFinite(n) || n < 1) return "";
+      return `every ${n}${UNIT_SUFFIX[state.intervalUnit]}`;
+    }
+    case "daily": {
+      const parsed = parseTimeOfDay(state.timeOfDay);
+      if (!parsed) return "";
+      return `${parsed.minute} ${parsed.hour} * * *`;
+    }
+    case "weekly": {
+      const parsed = parseTimeOfDay(state.timeOfDay);
+      if (!parsed) return "";
+      // Empty weekday selection → "*" (every day) rather than a backend
+      // 400. The Daily mode is the cleaner choice for that, but if the
+      // user toggles all days off in Weekly mode we still emit a valid
+      // expression instead of breaking the submit.
+      const days =
+        state.weekdays.length === 0
+          ? "*"
+          : [...state.weekdays].sort((a, b) => a - b).join(",");
+      return `${parsed.minute} ${parsed.hour} * * ${days}`;
+    }
+    case "monthly": {
+      const parsed = parseTimeOfDay(state.timeOfDay);
+      if (!parsed) return "";
+      const dom = Math.floor(state.dayOfMonth);
+      if (!Number.isFinite(dom) || dom < 1 || dom > 31) return "";
+      return `${parsed.minute} ${parsed.hour} ${dom} * *`;
+    }
+    case "once": {
+      const v = state.onceAt.trim();
+      if (!v) return "";
+      // <input type=datetime-local> already emits the
+      // "YYYY-MM-DDTHH:MM" shape that fromisoformat() accepts directly.
+      // Append ":00" so the backend's regex hits the "T" branch and
+      // the seconds component lines up with isoformat() output.
+      return v.length === 16 ? `${v}:00` : v;
+    }
+    case "custom":
+      return state.custom.trim();
+  }
+}
+
+function parseTimeOfDay(value: string): { hour: number; minute: number } | null {
+  if (!value || !/^\d{1,2}:\d{2}$/.test(value)) return null;
+  const [hh, mm] = value.split(":");
+  const hour = parseInt(hh, 10);
+  const minute = parseInt(mm, 10);
+  if (
+    !Number.isFinite(hour) ||
+    !Number.isFinite(minute) ||
+    hour < 0 ||
+    hour > 23 ||
+    minute < 0 ||
+    minute > 59
+  ) {
+    return null;
+  }
+  return { hour, minute };
+}
+
+/** Translation surface the human-readable describer needs. Passing it
+ * in (instead of importing ``useI18n``) keeps the helper pure and
+ * testable; the CronPage threads ``t.cron.scheduleDescribe`` through. */
+export interface ScheduleDescribeStrings {
+  /** Display when no schedule can be resolved (e.g. legacy/blank job). */
+  none: string;
+  /** "Every {n} minute(s)" — caller pluralises via {n}. */
+  everyMinutes: string;
+  everyHours: string;
+  everyDays: string;
+  /** "Daily at {time}" */
+  dailyAt: string;
+  /** "Weekly on {days} at {time}" */
+  weeklyAt: string;
+  /** "Monthly on the {day} at {time}" */
+  monthlyAt: string;
+  /** "Once at {time}" */
+  onceAt: string;
+  /** Weekday short names indexed 0..6 (Sunday-first). */
+  weekdaysShort: [string, string, string, string, string, string, string];
+  /** Ordinal suffix builder, e.g. "1st", "22nd". For locales that
+   * don't use English ordinals, just return ``String(day)``. */
+  ordinal: (day: number) => string;
+}
+
+/** Schedule shape stored on a ``CronJob`` row (see api.ts). */
+export interface ScheduleLike {
+  kind?: string;
+  expr?: string;
+  minutes?: number;
+  run_at?: string;
+  display?: string;
+}
+
+/** Human-readable description of a stored schedule.
+ *
+ * Prefers a structured render over the raw ``display`` string so cron
+ * expressions like ``30 14 * * 1,3,5`` show up as "Weekly on Mon, Wed,
+ * Fri at 14:30" instead of the raw five-field gibberish. Falls back to
+ * ``display`` / ``expr`` / ``none`` in that order if we can't make sense
+ * of the schedule (e.g. exotic cron with ranges, step values, or @reboot
+ * macros that we'd misrepresent if we tried to "humanize"). */
+export function describeSchedule(
+  schedule: ScheduleLike | undefined,
+  fallbackDisplay: string | undefined,
+  strings: ScheduleDescribeStrings,
+): string {
+  if (!schedule) return fallbackDisplay || strings.none;
+
+  if (schedule.kind === "interval" && typeof schedule.minutes === "number") {
+    return describeInterval(schedule.minutes, strings);
+  }
+
+  if (schedule.kind === "once" && schedule.run_at) {
+    return strings.onceAt.replace(
+      "{time}",
+      formatIsoLocal(schedule.run_at, false),
+    );
+  }
+
+  if (schedule.kind === "cron" && schedule.expr) {
+    const cronDesc = describeCronExpression(schedule.expr, strings);
+    if (cronDesc) return cronDesc;
+  }
+
+  // Try the raw expression as a last attempt — for legacy jobs stored
+  // without ``kind``, the ``schedule_display`` field often *is* the cron
+  // expression.
+  if (fallbackDisplay) {
+    const cronDesc = describeCronExpression(fallbackDisplay, strings);
+    if (cronDesc) return cronDesc;
+    return fallbackDisplay;
+  }
+  if (schedule.display) return schedule.display;
+  if (schedule.expr) return schedule.expr;
+  return strings.none;
+}
+
+function describeInterval(
+  minutes: number,
+  strings: ScheduleDescribeStrings,
+): string {
+  if (minutes <= 0) return strings.none;
+  if (minutes % 1440 === 0) {
+    return strings.everyDays.replace("{n}", String(minutes / 1440));
+  }
+  if (minutes % 60 === 0) {
+    return strings.everyHours.replace("{n}", String(minutes / 60));
+  }
+  return strings.everyMinutes.replace("{n}", String(minutes));
+}
+
+/** Recognise the common, well-shaped cron patterns and return a
+ * human sentence for them. Returns ``null`` when the expression has any
+ * ranges, steps, or other complexity that would be misleading to
+ * "humanize" — caller falls back to displaying the raw expression so
+ * the user sees what's actually scheduled.
+ *
+ * Strictly 5-field only: the backend ``parse_schedule`` also accepts the
+ * 6-field ``minute hour dom month dow year`` form, but humanising those
+ * by destructuring only the first five fields would silently drop the
+ * year and mislead the user (e.g. ``0 9 * * * 2099`` would read as
+ * "Daily at 09:00"). 6+ field expressions intentionally fall through to
+ * the raw-string fallback in {@link describeSchedule}. */
+function describeCronExpression(
+  expr: string,
+  strings: ScheduleDescribeStrings,
+): string | null {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) return null;
+  const [minField, hourField, domField, monField, dowField] = parts;
+
+  const month = monField === "*";
+  if (!month) return null; // we don't try to humanize per-month rules
+
+  const isLiteralOrList = (f: string) =>
+    /^\d+(,\d+)*$/.test(f) || /^\*$/.test(f);
+  if (!isLiteralOrList(minField) || !isLiteralOrList(hourField)) return null;
+  if (!isLiteralOrList(domField) || !isLiteralOrList(dowField)) return null;
+
+  // Star minutes/hours would mean "every minute" / "every hour" — we'd
+  // need a step-value handler ("*/15") to describe that cleanly, and
+  // that path is power-user territory. Bail to raw display.
+  if (minField === "*" || hourField === "*") return null;
+
+  const minutes = minField.split(",").map((n) => parseInt(n, 10));
+  const hours = hourField.split(",").map((n) => parseInt(n, 10));
+  if (minutes.length !== 1 || hours.length !== 1) return null;
+  if (
+    !Number.isFinite(minutes[0]) ||
+    !Number.isFinite(hours[0]) ||
+    hours[0] < 0 ||
+    hours[0] > 23 ||
+    minutes[0] < 0 ||
+    minutes[0] > 59
+  ) {
+    return null;
+  }
+  const time = `${pad2(hours[0])}:${pad2(minutes[0])}`;
+
+  const domAll = domField === "*";
+  const dowAll = dowField === "*";
+
+  if (domAll && dowAll) {
+    return strings.dailyAt.replace("{time}", time);
+  }
+
+  if (domAll && !dowAll) {
+    const days = dowField
+      .split(",")
+      .map((n) => parseInt(n, 10))
+      .filter((n) => Number.isFinite(n) && n >= 0 && n <= 6) as Weekday[];
+    if (days.length === 0) return null;
+    const labels = days
+      .map((d) => strings.weekdaysShort[d])
+      .filter(Boolean)
+      .join(", ");
+    return strings.weeklyAt
+      .replace("{days}", labels)
+      .replace("{time}", time);
+  }
+
+  if (!domAll && dowAll) {
+    const dom = parseInt(domField, 10);
+    if (!Number.isFinite(dom) || dom < 1 || dom > 31) return null;
+    return strings.monthlyAt
+      .replace("{day}", strings.ordinal(dom))
+      .replace("{time}", time);
+  }
+
+  // Both day-of-month AND day-of-week set is unusual and cron's
+  // OR-semantics for that combo are confusing — fall back to raw.
+  return null;
+}
+
+function pad2(n: number): string {
+  return n < 10 ? `0${n}` : String(n);
+}
+
+/** Format an ISO date for inline display. Drops the seconds + TZ
+ * suffix so the cron list stays compact. Falls back to the raw string
+ * if Date parsing fails. */
+function formatIsoLocal(iso: string, includeSeconds: boolean): string {
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return iso;
+  const yyyy = d.getFullYear();
+  const mm = pad2(d.getMonth() + 1);
+  const dd = pad2(d.getDate());
+  const hh = pad2(d.getHours());
+  const mi = pad2(d.getMinutes());
+  if (includeSeconds) {
+    return `${yyyy}-${mm}-${dd} ${hh}:${mi}:${pad2(d.getSeconds())}`;
+  }
+  return `${yyyy}-${mm}-${dd} ${hh}:${mi}`;
+}
+
+/** Convenience: build an English ordinal suffix ("1st", "2nd", "23rd").
+ * Most non-English locales should just return ``String(day)`` from
+ * their ``ordinal`` override. */
+export function englishOrdinal(day: number): string {
+  const d = Math.floor(day);
+  if (!Number.isFinite(d) || d < 1) return String(day);
+  const lastTwo = d % 100;
+  if (lastTwo >= 11 && lastTwo <= 13) return `${d}th`;
+  switch (d % 10) {
+    case 1:
+      return `${d}st`;
+    case 2:
+      return `${d}nd`;
+    case 3:
+      return `${d}rd`;
+    default:
+      return `${d}th`;
+  }
+}

package/src/lib/slashExec.ts

@@ -0,0 +1,163 @@
+/**
+ * Slash command execution pipeline for the web chat.
+ *
+ * Mirrors the Ink TUI's createSlashHandler.ts:
+ *
+ *   1. Parse the command into `name` + `arg`.
+ *   2. Try `slash.exec` — covers every registry-backed command the terminal
+ *      UI knows about (/help, /resume, /compact, /model, …). Output is
+ *      rendered into the transcript.
+ *   3. If `slash.exec` errors (command rejected, unknown, or needs client
+ *      behaviour), fall back to `command.dispatch` which returns a typed
+ *      directive: `exec` | `plugin` | `alias` | `skill` | `send`.
+ *   4. Each directive is dispatched to the appropriate callback.
+ *
+ * Keeping the pipeline here (instead of inline in ChatPage) lets future
+ * clients (SwiftUI, Android) implement the same logic by reading the same
+ * contract.
+ */
+
+import type { GatewayClient } from "@/lib/gatewayClient";
+
+export interface SlashExecResponse {
+  output?: string;
+  warning?: string;
+}
+
+export type CommandDispatchResponse =
+  | { type: "exec" | "plugin"; output?: string }
+  | { type: "alias"; target: string }
+  | { type: "skill"; name: string; message?: string }
+  | { type: "send"; message: string };
+
+export interface SlashExecCallbacks {
+  /** Render a transcript system message. */
+  sys(text: string): void;
+  /** Submit a user message to the agent (prompt.submit). */
+  send(message: string): Promise<void> | void;
+}
+
+export interface SlashExecOptions {
+  /** Raw command including the leading slash (e.g. "/model opus-4.6"). */
+  command: string;
+  /** Session id. If empty the call is still issued — some commands are session-less. */
+  sessionId: string;
+  gw: GatewayClient;
+  callbacks: SlashExecCallbacks;
+}
+
+export type SlashExecResult = "done" | "sent" | "error";
+
+/**
+ * Run a slash command. Returns the terminal state so callers can decide
+ * whether to clear the composer, queue retries, etc.
+ */
+export async function executeSlash({
+  command,
+  sessionId,
+  gw,
+  callbacks: { sys, send },
+}: SlashExecOptions): Promise<SlashExecResult> {
+  const { name, arg } = parseSlash(command);
+
+  if (!name) {
+    sys("empty slash command");
+    return "error";
+  }
+
+  // Primary dispatcher.
+  try {
+    const r = await gw.request<SlashExecResponse>("slash.exec", {
+      command: command.replace(/^\/+/, ""),
+      session_id: sessionId,
+    });
+    const body = r?.output || `/${name}: no output`;
+    sys(r?.warning ? `warning: ${r.warning}\n${body}` : body);
+    return "done";
+  } catch {
+    /* fall through to command.dispatch */
+  }
+
+  try {
+    const d = parseCommandDispatch(
+      await gw.request<unknown>("command.dispatch", {
+        name,
+        arg,
+        session_id: sessionId,
+      }),
+    );
+
+    if (!d) {
+      sys("error: invalid response: command.dispatch");
+      return "error";
+    }
+
+    switch (d.type) {
+      case "exec":
+      case "plugin":
+        sys(d.output ?? "(no output)");
+        return "done";
+
+      case "alias":
+        return executeSlash({
+          command: `/${d.target}${arg ? ` ${arg}` : ""}`,
+          sessionId,
+          gw,
+          callbacks: { sys, send },
+        });
+
+      case "skill":
+      case "send": {
+        const msg = d.message?.trim() ?? "";
+        if (!msg) {
+          sys(
+            `/${name}: ${d.type === "skill" ? "skill payload missing message" : "empty message"}`,
+          );
+          return "error";
+        }
+        if (d.type === "skill") sys(`⚡ loading skill: ${d.name}`);
+        await send(msg);
+        return "sent";
+      }
+    }
+  } catch (err) {
+    sys(`error: ${err instanceof Error ? err.message : String(err)}`);
+    return "error";
+  }
+}
+
+export function parseSlash(command: string): { name: string; arg: string } {
+  const m = command.replace(/^\/+/, "").match(/^(\S+)\s*(.*)$/);
+  return m ? { name: m[1], arg: m[2].trim() } : { name: "", arg: "" };
+}
+
+function parseCommandDispatch(raw: unknown): CommandDispatchResponse | null {
+  if (!raw || typeof raw !== "object") return null;
+
+  const r = raw as Record<string, unknown>;
+  const str = (v: unknown) => (typeof v === "string" ? v : undefined);
+
+  switch (r.type) {
+    case "exec":
+    case "plugin":
+      return { type: r.type, output: str(r.output) };
+
+    case "alias":
+      return typeof r.target === "string"
+        ? { type: "alias", target: r.target }
+        : null;
+
+    case "skill":
+      return typeof r.name === "string"
+        ? { type: "skill", name: r.name, message: str(r.message) }
+        : null;
+
+    case "send":
+      return typeof r.message === "string"
+        ? { type: "send", message: r.message }
+        : null;
+
+    default:
+      return null;
+  }
+}

package/src/lib/utils.ts

@@ -0,0 +1,35 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+
+/** Mondwest font only — use on layout shells; do not force normal-case here or `text-display` chrome (Segmented, badges) stops uppercasing. */
+export const themedFont = "font-mondwest";
+
+/** Mondwest body copy — sentence-case themed text (not uppercase chrome). */
+export const themedBody = "font-mondwest normal-case";
+
+/** Mondwest brand chrome — uppercase section headers and nav labels. */
+export const themedChrome = "font-mondwest text-display";
+
+/** Relative time from a Unix epoch timestamp (seconds). */
+export function timeAgo(ts: number): string {
+  const delta = Date.now() / 1000 - ts;
+  if (delta < 60) return "just now";
+  if (delta < 3600) return `${Math.floor(delta / 60)}m ago`;
+  if (delta < 86400) return `${Math.floor(delta / 3600)}h ago`;
+  if (delta < 172800) return "yesterday";
+  return `${Math.floor(delta / 86400)}d ago`;
+}
+
+/** Relative time from an ISO-8601 timestamp string. */
+export function isoTimeAgo(iso: string): string {
+  const delta = (Date.now() - new Date(iso).getTime()) / 1000;
+  if (delta < 0 || Number.isNaN(delta)) return "unknown";
+  if (delta < 60) return "just now";
+  if (delta < 3600) return `${Math.floor(delta / 60)}m ago`;
+  if (delta < 86400) return `${Math.floor(delta / 3600)}h ago`;
+  return `${Math.floor(delta / 86400)}d ago`;
+}

package/src/main.tsx

@@ -0,0 +1,25 @@
+import { createRoot } from "react-dom/client";
+import { BrowserRouter } from "react-router-dom";
+import "./index.css";
+import App from "./App";
+import { SystemActionsProvider } from "./contexts/SystemActions";
+import { I18nProvider } from "./i18n";
+import { exposePluginSDK } from "./plugins";
+import { ThemeProvider } from "./themes";
+import { NASTECH_BASE_PATH } from "./lib/api";
+
+// Expose the plugin SDK before rendering so plugins loaded via <script>
+// can access React, components, etc. immediately.
+exposePluginSDK();
+
+createRoot(document.getElementById("root")!).render(
+  <BrowserRouter basename={NASTECH_BASE_PATH || undefined}>
+    <I18nProvider>
+      <ThemeProvider>
+        <SystemActionsProvider>
+          <App />
+        </SystemActionsProvider>
+      </ThemeProvider>
+    </I18nProvider>
+  </BrowserRouter>,
+);