@codeoid/core 0.1.0

package/src/slash.ts

@@ -0,0 +1,247 @@
+/**
+ * Slash-command parsing + dispatch. Mirrors the TUI verbs:
+ *   /new <name> [workdir]    — create a session (workdir defaults to cwd)
+ *   /rename <name>           — rename focused session
+ *   /destroy                 — destroy focused session
+ *   /interrupt               — interrupt current turn
+ *   /rotate                  — rotate context (refresh skills/settings)
+ *   /mode <i|g|x>            — interactive | guarded | autonomous
+ *   /model <id|alias>        — switch model (opus / sonnet / haiku / full id)
+ *   /help                    — surface help modal (TODO P6)
+ *   /clear                   — clear prompt (handled by caller before dispatch)
+ *
+ * Pure functions — easy to unit-test. The `dispatch` helper takes a
+ * thin context object so we can mock send/newRequestId in tests.
+ */
+
+import type {
+  ClientMessage,
+  SessionMode,
+} from "@codeoid/protocol";
+
+export type SlashCommand =
+  | { kind: "new"; name: string; workdir?: string }
+  | { kind: "rename"; name: string }
+  | { kind: "destroy" }
+  | { kind: "interrupt" }
+  | { kind: "rotate" }
+  | { kind: "mode"; mode: SessionMode; maxTurns?: number }
+  | { kind: "model"; model: string; fallback?: string | null }
+  | { kind: "model-picker" }
+  | { kind: "help" }
+  | { kind: "clear" }
+  | { kind: "who" }
+  | { kind: "capabilities"; tab: "agents" | "skills" | "mcp" | "hooks" }
+  | { kind: "export" }
+  | { kind: "import" }
+  | { kind: "fork" };
+
+export function parseSlash(raw: string): SlashCommand | null {
+  const trimmed = raw.trim();
+  if (!trimmed.startsWith("/")) return null;
+  const head = trimmed.slice(1);
+  const [verb, ...rest] = head.split(/\s+/);
+  if (!verb) return null;
+
+  switch (verb.toLowerCase()) {
+    case "new": {
+      if (rest.length === 0) {
+        throw new Error("/new <name> [workdir]");
+      }
+      const [name, ...wd] = rest;
+      const workdir = wd.length > 0 ? wd.join(" ") : undefined;
+      return { kind: "new", name: name!, workdir };
+    }
+    case "rename": {
+      if (rest.length === 0) throw new Error("/rename <name>");
+      return { kind: "rename", name: rest.join(" ") };
+    }
+    case "destroy":
+      return { kind: "destroy" };
+    case "interrupt":
+      return { kind: "interrupt" };
+    case "rotate":
+      return { kind: "rotate" };
+    case "mode": {
+      const m = rest[0]?.toLowerCase();
+      if (!m) throw new Error("/mode <guarded|interactive|autonomous>");
+      const mode: SessionMode | undefined =
+        m === "i" || m === "interactive"
+          ? "interactive"
+          : // `a`/`auto`/`auto-allow` kept as backward-compat aliases for `guarded`.
+            m === "g" || m === "guarded" || m === "a" || m === "auto-allow" || m === "auto"
+            ? "guarded"
+            : m === "x" || m === "autonomous"
+              ? "autonomous"
+              : undefined;
+      if (!mode) throw new Error(`unknown mode: ${m}`);
+      const maxTurnsArg = rest[1];
+      const maxTurns = maxTurnsArg ? Number.parseInt(maxTurnsArg, 10) : undefined;
+      return {
+        kind: "mode",
+        mode,
+        ...(maxTurns !== undefined && Number.isFinite(maxTurns)
+          ? { maxTurns }
+          : {}),
+      };
+    }
+    case "model": {
+      // Bare `/model` opens the model picker (list + current). With an
+      // argument it switches directly.
+      if (rest.length === 0) return { kind: "model-picker" };
+      const [model, fallback] = rest;
+      return {
+        kind: "model",
+        model: model!,
+        ...(fallback !== undefined ? { fallback } : {}),
+      };
+    }
+    case "help":
+      return { kind: "help" };
+    case "clear":
+      return { kind: "clear" };
+    case "who":
+    case "whoami":
+      return { kind: "who" };
+    case "agents":
+    case "agent":
+      return { kind: "capabilities", tab: "agents" };
+    case "skills":
+    case "skill":
+      return { kind: "capabilities", tab: "skills" };
+    case "mcp":
+      return { kind: "capabilities", tab: "mcp" };
+    case "hooks":
+    case "hook":
+      return { kind: "capabilities", tab: "hooks" };
+    case "export":
+    case "share":
+      return { kind: "export" };
+    case "import":
+      return { kind: "import" };
+    case "fork":
+      return { kind: "fork" };
+    default:
+      throw new Error(`unknown slash command: /${verb}`);
+  }
+}
+
+export interface SlashContext {
+  sessionId: string;
+  send: (msg: ClientMessage) => void;
+  newRequestId: () => string;
+  removeSession: (id: string) => void;
+  /**
+   * Send a command and await the daemon's response, rejecting on
+   * `response.error`. When provided, fallible commands route through this so
+   * the daemon's error (e.g. "Unknown model") surfaces via `report`. Falls
+   * back to fire-and-forget `send` when absent (e.g. in tests).
+   */
+  request?: (msg: ClientMessage) => Promise<unknown>;
+  /** Surface a command error to the user (wired to the prompt's error line). */
+  report?: (message: string) => void;
+  /** Optional UI hooks — caller provides as needed. */
+  showHelp?: () => void;
+  showModelPicker?: () => void;
+  showIdentity?: () => void;
+  showCapabilities?: (tab: "agents" | "skills" | "mcp" | "hooks") => void;
+  showExport?: () => void;
+  showImport?: () => void;
+}
+
+export function dispatchSlash(cmd: SlashCommand, ctx: SlashContext): void {
+  // Send a daemon command, surfacing any `response.error` via `report` so
+  // the user gets feedback (e.g. `/model o` → "Unknown model"). Falls back
+  // to fire-and-forget when no request channel is wired.
+  const fire = (msg: ClientMessage): void => {
+    if (ctx.request) {
+      ctx.request(msg).catch((e) =>
+        ctx.report?.(e instanceof Error ? e.message : String(e)),
+      );
+    } else {
+      ctx.send(msg);
+    }
+  };
+
+  switch (cmd.kind) {
+    case "new":
+      fire({
+        type: "session.create",
+        id: ctx.newRequestId(),
+        name: cmd.name,
+        workdir: cmd.workdir ?? ".",
+      });
+      return;
+    case "rename":
+      fire({
+        type: "session.rename",
+        id: ctx.newRequestId(),
+        sessionId: ctx.sessionId,
+        name: cmd.name,
+      });
+      return;
+    case "destroy":
+      fire({
+        type: "session.destroy",
+        id: ctx.newRequestId(),
+        sessionId: ctx.sessionId,
+      });
+      // Optimistically drop locally; the daemon's broadcast will confirm.
+      ctx.removeSession(ctx.sessionId);
+      return;
+    case "interrupt":
+      fire({
+        type: "session.interrupt",
+        id: ctx.newRequestId(),
+        sessionId: ctx.sessionId,
+      });
+      return;
+    case "rotate":
+      fire({
+        type: "session.rotate",
+        id: ctx.newRequestId(),
+        sessionId: ctx.sessionId,
+      });
+      return;
+    case "mode":
+      fire({
+        type: "session.set_mode",
+        id: ctx.newRequestId(),
+        sessionId: ctx.sessionId,
+        mode: cmd.mode,
+        ...(cmd.maxTurns !== undefined ? { maxTurns: cmd.maxTurns } : {}),
+      });
+      return;
+    case "model":
+      fire({
+        type: "session.set_model",
+        id: ctx.newRequestId(),
+        sessionId: ctx.sessionId,
+        model: cmd.model,
+        ...(cmd.fallback !== undefined ? { fallbackModel: cmd.fallback } : {}),
+      });
+      return;
+    case "model-picker":
+      ctx.showModelPicker?.();
+      return;
+    case "help":
+      ctx.showHelp?.();
+      return;
+    case "clear":
+      // Pure UI side-effect handled by the caller.
+      return;
+    case "who":
+      ctx.showIdentity?.();
+      return;
+    case "capabilities":
+      ctx.showCapabilities?.(cmd.tab);
+      return;
+    case "export":
+      ctx.showExport?.();
+      return;
+    case "import":
+    case "fork":
+      ctx.showImport?.();
+      return;
+  }
+}

package/src/usage-days.ts

@@ -0,0 +1,40 @@
+/**
+ * UTC day-bucket helpers for the analytics panel.
+ *
+ * The daemon buckets usage by SQLite `date(created_at/1000, 'unixepoch')`,
+ * which is UTC. The client must derive its bucket keys and "today" in UTC
+ * too — the previous implementation stepped days with local-time
+ * `setDate()/getDate()` and then read the key via `toISOString()` (UTC),
+ * which mismatches daemon buckets for any user not on UTC and can
+ * skip/duplicate a day around DST transitions.
+ */
+
+export interface DayCostBucket {
+  day: string;
+  costUsd: number;
+}
+
+const DAY_MS = 86_400_000; // UTC days have no DST; fixed stepping is exact.
+
+/** `YYYY-MM-DD` in UTC for an epoch-ms timestamp. */
+export function utcDayKey(ms: number): string {
+  return new Date(ms).toISOString().slice(0, 10);
+}
+
+/**
+ * Expand sparse daemon buckets into a dense `days`-long window ending at
+ * the UTC day containing `nowMs`, filling gaps with zero cost.
+ */
+export function padDays(
+  data: ReadonlyArray<{ day: string; costUsd: number }>,
+  days: number,
+  nowMs: number = Date.now(),
+): DayCostBucket[] {
+  const map = new Map(data.map((d) => [d.day, d.costUsd]));
+  const result: DayCostBucket[] = [];
+  for (let i = days - 1; i >= 0; i--) {
+    const key = utcDayKey(nowMs - i * DAY_MS);
+    result.push({ day: key, costUsd: map.get(key) ?? 0 });
+  }
+  return result;
+}