@saadnvd1/agent-os 0.3.770 → 0.3.775

package/lib/palette/registry.ts

@@ -3,6 +3,36 @@
  * take them back the same way, so the palette itself knows no feature.
  */
 
+export type PaletteTab =
+  "all" | "sessions" | "commands" | "settings" | "conversations";
+
+export const PALETTE_TABS: { id: PaletteTab; label: string }[] = [
+  { id: "all", label: "All" },
+  { id: "sessions", label: "Sessions" },
+  { id: "commands", label: "Commands" },
+  { id: "settings", label: "Settings" },
+  { id: "conversations", label: "Conversations" },
+];
+
+// Which tab each heading's commands are found under; a heading not listed is
+// a command. A command can name its own tab instead.
+const GROUP_TAB: Record<string, PaletteTab> = {
+  Sessions: "sessions",
+  Settings: "settings",
+  Conversations: "conversations",
+};
+
+// Headings whose commands act on the focused session.
+const SESSION_GROUPS = new Set(["Chat", "Task"]);
+
+export function tabOf(c: PaletteCommand): PaletteTab {
+  return c.tab ?? GROUP_TAB[c.group] ?? "commands";
+}
+
+export function actsOnFocusedSession(c: PaletteCommand): boolean {
+  return SESSION_GROUPS.has(c.group);
+}
+
 export interface PaletteCommand {
   id: string;
   title: string;
@@ -14,6 +44,10 @@ export interface PaletteCommand {
   hint?: string;
   // A line under the title (what a conversation hit said).
   detail?: string;
+  // Overrides the tab its group maps to.
+  tab?: PaletteTab;
+  // A session that is working or waiting on the user.
+  status?: "running" | "waiting";
   // Running it leaves the palette open (it changes the palette itself).
   keepOpen?: boolean;
   icon?: unknown;
@@ -84,25 +118,45 @@ export function fuzzyScore(query: string, text: string): number | null {
   return score;
 }
 
-// The commands a query finds, best first; all of them, in order, for none.
-export function matchCommands(
+export interface Scored {
+  c: PaletteCommand;
+  score: number;
+}
+
+// The commands a query finds, best first, with their scores. `boost` (0 to 1,
+// e.g. how much it's used) scales a match up by at most half: it can break a
+// close call, never rescue a non-match or outrank a far better match. With no
+// query the boost alone orders them, registry order breaking ties.
+export function scoreCommands(
   commands: PaletteCommand[],
-  query: string
-): PaletteCommand[] {
-  if (!query.trim()) return commands;
+  query: string,
+  boost: (c: PaletteCommand) => number = () => 0
+): Scored[] {
+  const empty = !query.trim();
   return commands
     .map((c, i) => {
-      const scores = [c.title, ...(c.keywords ?? []), c.group].map(
-        (text, j) => {
-          const s = fuzzyScore(query, text);
-          // A title match counts most.
-          return s === null ? null : j === 0 ? s * 1.5 : s;
-        }
-      );
-      const best = Math.max(...scores.map((s) => s ?? -Infinity));
-      return { c, i, best };
+      let base = 0;
+      if (!empty) {
+        const scores = [c.title, ...(c.keywords ?? []), c.group].map(
+          (text, j) => {
+            const s = fuzzyScore(query, text);
+            // A title match counts most.
+            return s === null ? null : j === 0 ? s * 1.5 : s;
+          }
+        );
+        base = Math.max(...scores.map((s) => s ?? -Infinity));
+      }
+      const b = boost(c);
+      return { c, i, base, score: empty ? b : base + Math.abs(base) * 0.5 * b };
     })
-    .filter((m) => m.best > -Infinity)
-    .sort((a, b) => b.best - a.best || a.i - b.i)
-    .map((m) => m.c);
+    .filter((m) => m.base > -Infinity)
+    .sort((a, b) => b.score - a.score || a.i - b.i)
+    .map(({ c, score }) => ({ c, score }));
+}
+
+export function matchCommands(
+  commands: PaletteCommand[],
+  query: string
+): PaletteCommand[] {
+  return scoreCommands(commands, query).map((m) => m.c);
 }

package/lib/palette/sections.ts

@@ -0,0 +1,143 @@
+import {
+  PALETTE_TABS,
+  actsOnFocusedSession,
+  scoreCommands,
+  tabOf,
+  type PaletteCommand,
+  type PaletteTab,
+} from "./registry";
+import { recentIds, usageBoost, type Usage } from "./usage";
+
+export interface Section {
+  name: string;
+  items: PaletteCommand[];
+  // The tab that lists the whole section, when this is only part of it.
+  more?: { tab: PaletteTab; count: number };
+}
+
+export const PER_TAB = 5;
+export const RECENT = 5;
+const NEEDS_YOU = 5;
+const SUGGESTED = 6;
+
+const label = (tab: PaletteTab) =>
+  PALETTE_TABS.find((t) => t.id === tab)?.label ?? tab;
+
+export const boostFor = (usage: Usage, now: number) => (c: PaletteCommand) =>
+  usageBoost(usage[c.id], now);
+
+// What a query finds in All: each tab's best few under its heading, the
+// strongest group first, with how many more its tab holds. Conversations are
+// the caller's, to put last.
+export function allSections(
+  commands: PaletteCommand[],
+  query: string,
+  usage: Usage,
+  now: number
+): Section[] {
+  const scored = scoreCommands(commands, query, boostFor(usage, now));
+  const byTab = new Map<PaletteTab, typeof scored>();
+  for (const m of scored) {
+    const tab = tabOf(m.c);
+    if (tab === "conversations") continue;
+    byTab.set(tab, [...(byTab.get(tab) ?? []), m]);
+  }
+  return [...byTab.entries()]
+    .sort((a, b) => b[1][0].score - a[1][0].score)
+    .map(([tab, ms]) => ({
+      name: label(tab),
+      items: ms.slice(0, PER_TAB).map((m) => m.c),
+      ...(ms.length > PER_TAB
+        ? { more: { tab, count: ms.length } }
+        : undefined),
+    }));
+}
+
+// One tab's commands, for a query or (ordered by use) without one.
+export function tabItems(
+  commands: PaletteCommand[],
+  tab: PaletteTab,
+  query: string,
+  usage: Usage,
+  now: number
+): PaletteCommand[] {
+  return scoreCommands(
+    commands.filter((c) => tabOf(c) === tab),
+    query,
+    boostFor(usage, now)
+  ).map((m) => m.c);
+}
+
+// The short list All opens on: the last things run, sessions that need the
+// user or are working, and what the focused session can do.
+export function emptySections(
+  commands: PaletteCommand[],
+  usage: Usage
+): Section[] {
+  const seen = new Set<string>();
+  const take = (items: PaletteCommand[], limit: number) => {
+    const out: PaletteCommand[] = [];
+    for (const c of items) {
+      if (out.length >= limit) break;
+      if (seen.has(c.id)) continue;
+      seen.add(c.id);
+      out.push(c);
+    }
+    return out;
+  };
+  // A session that needs you is listed there, not also under Recent.
+  const rank = (c: PaletteCommand) => (c.status === "waiting" ? 0 : 1);
+  const busy = take(
+    commands.filter((c) => c.status).sort((a, b) => rank(a) - rank(b)),
+    NEEDS_YOU
+  );
+  const here = take(commands.filter(actsOnFocusedSession), 5);
+  const byId = new Map(commands.map((c) => [c.id, c]));
+  const recent = take(
+    recentIds(usage, commands.length)
+      .map((id) => byId.get(id))
+      .filter((c): c is PaletteCommand => !!c),
+    RECENT
+  );
+  const sections: Section[] = [
+    { name: "Recent", items: recent },
+    { name: "Needs you / running", items: busy },
+    { name: "This session", items: here },
+  ];
+  // A first run has no history: offer the commands that start things.
+  if (recent.length + busy.length + here.length < 4)
+    sections.push({
+      name: "Suggested",
+      items: take(
+        commands.filter((c) => tabOf(c) === "commands"),
+        SUGGESTED
+      ),
+    });
+  return sections.filter((s) => s.items.length);
+}
+
+// Each cut-short section ends with a row that opens its whole tab.
+export function withSeeAll(
+  sections: Section[],
+  open: (tab: PaletteTab) => void,
+  icon?: unknown
+): Section[] {
+  return sections.map((s) => {
+    const more = s.more;
+    if (!more) return s;
+    return {
+      ...s,
+      items: [
+        ...s.items,
+        {
+          id: `see-all:${more.tab}`,
+          title: `See all ${more.count} →`,
+          group: s.name,
+          icon,
+          keepOpen: true,
+          run: () => open(more.tab),
+        },
+      ],
+    };
+  });
+}

package/lib/palette/tabs.ts

@@ -0,0 +1,21 @@
+import { PALETTE_TABS, type PaletteTab } from "./registry";
+
+const PREFIXES: Record<string, PaletteTab> = {
+  ">": "commands",
+  "@": "sessions",
+};
+
+// A leading `>` or `@` on a fresh query picks a tab; null when there's none.
+export function parsePrefix(
+  text: string
+): { tab: PaletteTab; text: string } | null {
+  const tab = PREFIXES[text[0]];
+  return tab ? { tab, text: text.slice(1).trimStart() } : null;
+}
+
+// The next tab (or the one before), wrapping round.
+export function cycleTab(tab: PaletteTab, by: 1 | -1): PaletteTab {
+  const n = PALETTE_TABS.length;
+  const i = PALETTE_TABS.findIndex((t) => t.id === tab);
+  return PALETTE_TABS[(i + by + n) % n].id;
+}

package/lib/palette/usage.ts

@@ -0,0 +1,81 @@
+export interface UsageEntry {
+  count: number;
+  last: number;
+}
+export type Usage = Record<string, UsageEntry>;
+
+export const USAGE_KEY = "agentOS-palette-usage";
+export const MAX_USAGE = 200;
+const DAY = 86_400_000;
+const HALF_LIFE_DAYS = 14;
+// Uses at which the count part of the boost tops out.
+const SATURATES_AT = 20;
+
+// How strongly past use favours an item, 0 to 1: more uses count more (with
+// diminishing returns) and the whole fades by half every two weeks.
+export function usageBoost(entry: UsageEntry | undefined, now: number): number {
+  if (!entry) return 0;
+  const age = Math.max(0, now - entry.last) / DAY;
+  const weight = Math.min(
+    1,
+    Math.log2(1 + entry.count) / Math.log2(1 + SATURATES_AT)
+  );
+  return weight * Math.pow(0.5, age / HALF_LIFE_DAYS);
+}
+
+// The usage with one more run of `id`, keeping the MAX_USAGE items that
+// matter most right now.
+export function recordUse(usage: Usage, id: string, now: number): Usage {
+  const next: Usage = {
+    ...usage,
+    [id]: { count: (usage[id]?.count ?? 0) + 1, last: now },
+  };
+  const ids = Object.keys(next);
+  if (ids.length <= MAX_USAGE) return next;
+  const keep = ids
+    .sort((a, b) => usageBoost(next[b], now) - usageBoost(next[a], now))
+    .slice(0, MAX_USAGE);
+  return Object.fromEntries(keep.map((k) => [k, next[k]]));
+}
+
+// The ids last run most recently, newest first.
+export function recentIds(usage: Usage, limit: number): string[] {
+  return Object.entries(usage)
+    .sort((a, b) => b[1].last - a[1].last)
+    .slice(0, limit)
+    .map(([id]) => id);
+}
+
+function valid(e: unknown): e is UsageEntry {
+  const u = e as UsageEntry | null;
+  return (
+    !!u && Number.isFinite(u.count) && Number.isFinite(u.last) && u.count > 0
+  );
+}
+
+export function loadUsage(): Usage {
+  try {
+    const raw: unknown = JSON.parse(localStorage.getItem(USAGE_KEY) ?? "{}");
+    if (!raw || typeof raw !== "object") return {};
+    const usage: Usage = {};
+    for (const [id, e] of Object.entries(raw)) if (valid(e)) usage[id] = e;
+    return usage;
+  } catch {
+    return {};
+  }
+}
+
+export function saveUsage(usage: Usage): void {
+  try {
+    localStorage.setItem(USAGE_KEY, JSON.stringify(usage));
+  } catch {
+    // Private mode or a full disk: ranking just forgets.
+  }
+}
+
+// Records a run in storage and returns the new usage.
+export function noteUse(id: string, now = Date.now()): Usage {
+  const next = recordUse(loadUsage(), id, now);
+  saveUsage(next);
+  return next;
+}

package/lib/security/demo.ts

@@ -64,6 +64,7 @@ export const STATIC_SIBLINGS = [
   "browse",
   "check",
   "clone",
+  "compare",
   "connect",
   "detect",
   "done-idle",
@@ -84,6 +85,7 @@ export const STATIC_SIBLINGS = [
   "pdf",
   "preview",
   "queue",
+  "resolve",
   "status",
 ];
 // No leading "-": an id that reaches a command line can't read as an option.
@@ -101,6 +103,7 @@ const READS = [
   "sessions/[id]/pr",
   "sessions/[id]/artifacts",
   "sessions/[id]/artifacts/[id]",
+  "sessions/[id]/artifacts/[id]/compare",
   "sessions/[id]/setup",
   "sessions/[id]/preview",
   "projects",

package/lib/share/markdown.ts

@@ -12,6 +12,7 @@ import { toMarkdown } from "mdast-util-to-markdown";
 import type { Nodes as HastNodes } from "hast";
 import type { Nodes, Parents, RootContent } from "mdast";
 import type { Snapshot, SnapshotItem } from "./snapshot";
+import { EARLIER_NOT_SHARED, LATER_NOT_SHARED } from "./range";
 
 const DROP_TAGS = new Set([
   "script",
@@ -119,7 +120,9 @@ export function chatToMarkdown(
 ): string {
   const parts = [
     agentHeader(snap.title, opts.sharedAt),
+    ...(snap.cutBefore ? [`*${EARLIER_NOT_SHARED}.*`] : []),
     ...snap.items.map(itemToMarkdown),
+    ...(snap.cutAfter ? [`*${LATER_NOT_SHARED}.*`] : []),
   ];
   if (snap.toolsHidden) parts.push("*Tool calls and thinking were left out.*");
   return parts.join("\n\n") + "\n";

package/lib/share/range.ts

@@ -0,0 +1,189 @@
+// Which part of a chat a share covers. Pure, imports nothing outside itself,
+// so the dialog and the server resolve a range the same way.
+
+/** A range of messages by id, both ends included. */
+export interface ShareRange {
+  fromId: string;
+  toId: string;
+}
+
+export interface RangeRow {
+  id: string;
+  type: string;
+  createdAt?: number;
+}
+
+export type RangePreset = "last" | "last5" | "today" | "all";
+
+export const PRESETS: { id: RangePreset; label: string }[] = [
+  { id: "last", label: "Last exchange" },
+  { id: "last5", label: "Last 5 exchanges" },
+  { id: "today", label: "Today" },
+  { id: "all", label: "Whole chat" },
+];
+
+export const EARLIER_NOT_SHARED = "Earlier messages not shared";
+export const LATER_NOT_SHARED = "Later messages not shared";
+
+export const DEFAULT_PRESET: RangePreset = "last";
+
+/** Positions in `ids` that a range covers, or null when an end isn't there or they're backwards. A missing end means the chat's own start or end. */
+export function windowOf(
+  ids: string[],
+  fromId?: string,
+  toId?: string
+): { start: number; end: number } | null {
+  const start = fromId === undefined ? 0 : ids.indexOf(fromId);
+  const end = toId === undefined ? ids.length - 1 : ids.indexOf(toId);
+  if (start < 0 || end < 0 || start > end) return null;
+  return { start, end };
+}
+
+/** Where each exchange begins: a user prompt. Rows before the first prompt are an exchange of their own. */
+export function exchangeStarts(rows: RangeRow[]): number[] {
+  const starts = rows.flatMap((r, i) => (r.type === "user" ? [i] : []));
+  if (rows.length && starts[0] !== 0) starts.unshift(0);
+  return starts;
+}
+
+const startOfDay = (now: Date) =>
+  new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+
+/** The range a preset means, or null when it has nothing to pick (no messages today). */
+export function presetRange(
+  rows: RangeRow[],
+  preset: RangePreset,
+  now: Date
+): ShareRange | null {
+  if (!rows.length) return null;
+  const last = rows[rows.length - 1].id;
+  const starts = exchangeStarts(rows);
+  let from: number;
+  switch (preset) {
+    case "last":
+      from = starts[starts.length - 1];
+      break;
+    case "last5":
+      from = starts[Math.max(0, starts.length - 5)];
+      break;
+    case "all":
+      from = 0;
+      break;
+    case "today": {
+      const day = startOfDay(now);
+      const todays = rows
+        .map((r, i) => ({ r, i }))
+        .filter(({ r }) => (r.createdAt ?? 0) >= day);
+      if (!todays.length) return null;
+      from = (todays.find(({ r }) => r.type === "user") ?? todays[0]).i;
+      break;
+    }
+  }
+  return { fromId: rows[from].id, toId: last };
+}
+
+/** The preset a range equals, or null for a custom one. */
+export function activePreset(
+  rows: RangeRow[],
+  range: ShareRange | null,
+  now: Date
+): RangePreset | null {
+  if (!range) return null;
+  return (
+    PRESETS.find((p) => {
+      const r = presetRange(rows, p.id, now);
+      return r && r.fromId === range.fromId && r.toId === range.toId;
+    })?.id ?? null
+  );
+}
+
+/** From a message to the latest one. */
+export function rangeFromHere(rows: RangeRow[], id: string): ShareRange | null {
+  return rows.some((r) => r.id === id)
+    ? { fromId: id, toId: rows[rows.length - 1].id }
+    : null;
+}
+
+/** A click sets the range to one message; shift-click stretches it from the anchor to the clicked one, either direction. */
+export function clickRange(
+  rows: RangeRow[],
+  anchorId: string | null,
+  clickedId: string,
+  extend: boolean
+): ShareRange {
+  const a = extend && anchorId ? rows.findIndex((r) => r.id === anchorId) : -1;
+  const b = rows.findIndex((r) => r.id === clickedId);
+  if (a < 0 || b < 0) return { fromId: clickedId, toId: clickedId };
+  const [lo, hi] = a <= b ? [a, b] : [b, a];
+  return { fromId: rows[lo].id, toId: rows[hi].id };
+}
+
+/** Rows the range covers (all of them when there is none yet). */
+export function inRange<T extends RangeRow>(
+  rows: T[],
+  range: ShareRange | null
+): T[] {
+  if (!range) return rows;
+  const w = windowOf(
+    rows.map((r) => r.id),
+    range.fromId,
+    range.toId
+  );
+  return w ? rows.slice(w.start, w.end + 1) : [];
+}
+
+const clock = (d: Date) => {
+  const h = d.getHours();
+  const m = String(d.getMinutes()).padStart(2, "0");
+  return { text: `${h % 12 || 12}:${m}`, ampm: h < 12 ? "AM" : "PM" };
+};
+
+const sameDay = (a: Date, b: Date) =>
+  a.getFullYear() === b.getFullYear() &&
+  a.getMonth() === b.getMonth() &&
+  a.getDate() === b.getDate();
+
+const MONTHS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec",
+];
+
+const dayLabel = (d: Date) => `${MONTHS[d.getMonth()]} ${d.getDate()}`;
+
+/** "2:14–2:40 PM", "11:50 AM–12:10 PM", or with dates when it crosses a day. */
+export function timeSpan(from: number, to: number): string {
+  const a = new Date(from);
+  const b = new Date(to);
+  const ca = clock(a);
+  const cb = clock(b);
+  if (!sameDay(a, b))
+    return `${dayLabel(a)}, ${ca.text} ${ca.ampm} – ${dayLabel(b)}, ${cb.text} ${cb.ampm}`;
+  if (ca.text === cb.text && ca.ampm === cb.ampm)
+    return `${ca.text} ${ca.ampm}`;
+  return ca.ampm === cb.ampm
+    ? `${ca.text}–${cb.text} ${cb.ampm}`
+    : `${ca.text} ${ca.ampm}–${cb.text} ${cb.ampm}`;
+}
+
+/** "Sharing 6 of 120 messages · 2:14–2:40 PM". */
+export function rangeSummary(total: number, shared: RangeRow[]): string {
+  if (!shared.length) return "Nothing selected to share";
+  const noun = total === 1 ? "message" : "messages";
+  const times = shared
+    .map((r) => r.createdAt)
+    .filter((t): t is number => typeof t === "number" && t > 0);
+  const base = `Sharing ${shared.length} of ${total} ${noun}`;
+  return times.length
+    ? `${base} · ${timeSpan(Math.min(...times), Math.max(...times))}`
+    : base;
+}

package/lib/share/render.tsx

@@ -14,6 +14,7 @@ import remarkGfm from "remark-gfm";
 import { Prism as Highlighter } from "react-syntax-highlighter";
 import type { Snapshot, SnapshotItem } from "./snapshot";
 import { STYLES } from "./styles";
+import { EARLIER_NOT_SHARED, LATER_NOT_SHARED } from "./range";
 
 export const MAX_SHARE_BYTES = 5 * 1024 * 1024;
 
@@ -123,9 +124,11 @@ export function renderChatSnapshot(
 ): string {
   const body = renderToStaticMarkup(
     <>
+      {snapshot.cutBefore && <div className="cut">{EARLIER_NOT_SHARED}</div>}
       {snapshot.items.map((item) => (
         <Item key={item.id} item={item} />
       ))}
+      {snapshot.cutAfter && <div className="cut">{LATER_NOT_SHARED}</div>}
     </>
   );
   const date = opts.sharedAt.slice(0, 10);