@stigmer/react 0.4.8 → 0.5.1

package/src/session/__tests__/session-spec-converters.test.ts

@@ -0,0 +1,185 @@
+import { describe, it, expect } from "vitest";
+import {
+  specWorkspaceToInput,
+  specMcpUsagesToInput,
+  specSkillRefsToInput,
+} from "../session-spec-converters";
+import type { Session } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+
+type SessionSpec = Session["spec"];
+
+function makeSpec(overrides: Partial<NonNullable<SessionSpec>> = {}): SessionSpec {
+  return {
+    agentInstanceId: "",
+    subject: "",
+    threadId: "",
+    sandboxId: "",
+    metadata: {},
+    workspaceEntries: [],
+    mcpServerUsages: [],
+    skillRefs: [],
+    runnerId: "",
+    harness: 0,
+    cursorMode: 0,
+    ...overrides,
+  } as unknown as SessionSpec;
+}
+
+describe("specWorkspaceToInput", () => {
+  it("returns undefined for undefined spec", () => {
+    expect(specWorkspaceToInput(undefined)).toBeUndefined();
+  });
+
+  it("returns empty array for spec with no workspace entries", () => {
+    expect(specWorkspaceToInput(makeSpec())).toEqual([]);
+  });
+
+  it("converts git repo entries", () => {
+    const spec = makeSpec({
+      workspaceEntries: [
+        {
+          name: "my-repo",
+          source: {
+            source: {
+              case: "gitRepo" as const,
+              value: { url: "https://github.com/org/repo", branch: "main", commit: "", depth: 0 },
+            },
+          },
+        },
+      ] as unknown as SessionSpec extends undefined ? never : NonNullable<SessionSpec>["workspaceEntries"],
+    });
+
+    const result = specWorkspaceToInput(spec);
+    expect(result).toEqual([
+      {
+        name: "my-repo",
+        source: {
+          gitRepo: {
+            url: "https://github.com/org/repo",
+            branch: "main",
+            commit: undefined,
+            depth: undefined,
+          },
+        },
+      },
+    ]);
+  });
+
+  it("converts local path entries", () => {
+    const spec = makeSpec({
+      workspaceEntries: [
+        {
+          name: "local",
+          source: {
+            source: {
+              case: "localPath" as const,
+              value: { path: "/home/user/project" },
+            },
+          },
+        },
+      ] as unknown as SessionSpec extends undefined ? never : NonNullable<SessionSpec>["workspaceEntries"],
+    });
+
+    const result = specWorkspaceToInput(spec);
+    expect(result).toEqual([
+      {
+        name: "local",
+        source: {
+          localPath: { path: "/home/user/project" },
+        },
+      },
+    ]);
+  });
+});
+
+describe("specMcpUsagesToInput", () => {
+  it("returns undefined for undefined spec", () => {
+    expect(specMcpUsagesToInput(undefined)).toBeUndefined();
+  });
+
+  it("returns empty array for spec with no MCP server usages", () => {
+    expect(specMcpUsagesToInput(makeSpec())).toEqual([]);
+  });
+
+  it("converts MCP server usages with ref and enabled tools", () => {
+    const spec = makeSpec({
+      mcpServerUsages: [
+        {
+          mcpServerRef: {
+            org: "acme",
+            slug: "github-tools",
+            version: "v1",
+            kind: ApiResourceKind.mcp_server,
+          },
+          enabledTools: ["create_issue", "list_prs"],
+          toolApprovalOverrides: [],
+        },
+      ] as unknown as NonNullable<SessionSpec>["mcpServerUsages"],
+    });
+
+    const result = specMcpUsagesToInput(spec);
+    expect(result).toEqual([
+      {
+        mcpServerRef: {
+          org: "acme",
+          slug: "github-tools",
+          version: "v1",
+          kind: ApiResourceKind.mcp_server,
+        },
+        enabledTools: ["create_issue", "list_prs"],
+        toolApprovalOverrides: undefined,
+      },
+    ]);
+  });
+
+  it("converts MCP server usages with tool approval overrides", () => {
+    const spec = makeSpec({
+      mcpServerUsages: [
+        {
+          mcpServerRef: {
+            org: "acme",
+            slug: "shell",
+            version: "",
+            kind: ApiResourceKind.mcp_server,
+          },
+          enabledTools: [],
+          toolApprovalOverrides: [
+            { toolName: "exec", requiresApproval: true, message: "Dangerous" },
+          ],
+        },
+      ] as unknown as NonNullable<SessionSpec>["mcpServerUsages"],
+    });
+
+    const result = specMcpUsagesToInput(spec);
+    expect(result).toHaveLength(1);
+    expect(result![0].toolApprovalOverrides).toEqual([
+      { toolName: "exec", requiresApproval: true, message: "Dangerous" },
+    ]);
+  });
+});
+
+describe("specSkillRefsToInput", () => {
+  it("returns undefined for undefined spec", () => {
+    expect(specSkillRefsToInput(undefined)).toBeUndefined();
+  });
+
+  it("returns empty array for spec with no skill refs", () => {
+    expect(specSkillRefsToInput(makeSpec())).toEqual([]);
+  });
+
+  it("converts skill references", () => {
+    const spec = makeSpec({
+      skillRefs: [
+        { org: "acme", slug: "code-review", version: "v2", kind: ApiResourceKind.skill },
+        { org: "acme", slug: "testing", version: "", kind: ApiResourceKind.skill },
+      ] as unknown as NonNullable<SessionSpec>["skillRefs"],
+    });
+
+    const result = specSkillRefsToInput(spec);
+    expect(result).toEqual([
+      { org: "acme", slug: "code-review", version: "v2", kind: ApiResourceKind.skill },
+      { org: "acme", slug: "testing", version: undefined, kind: ApiResourceKind.skill },
+    ]);
+  });
+});

package/src/session/__tests__/useNewSessionFlow.test.tsx

@@ -82,7 +82,7 @@ const TEST_MODELS = parseRegistryJson({
 });
 
 function createWrapper() {
-  const state: ModelRegistryState = { models: TEST_MODELS, isLoading: false, error: null };
+  const state: ModelRegistryState = { models: TEST_MODELS, isLoading: false, error: null, refetch: () => {} };
   return function Wrapper({ children }: { children: ReactNode }) {
     return (
       <ModelRegistryContext.Provider value={state}>
@@ -284,7 +284,7 @@ describe("useNewSessionFlow", () => {
   describe("model validation timing", () => {
     it("does not restore model while registry is loading", () => {
       localStorage.setItem(STORAGE_KEY_MODEL_NATIVE, DEFAULT_MODEL_ID);
-      const loadingState: ModelRegistryState = { models: [], isLoading: true, error: null };
+      const loadingState: ModelRegistryState = { models: [], isLoading: true, error: null, refetch: () => {} };
 
       function LoadingWrapper({ children }: { children: ReactNode }) {
         return (

package/src/session/__tests__/usePersistedModel.test.tsx

@@ -14,7 +14,7 @@ const TEST_MODELS = parseRegistryJson({
 });
 
 function createWrapper() {
-  const state: ModelRegistryState = { models: TEST_MODELS, isLoading: false, error: null };
+  const state: ModelRegistryState = { models: TEST_MODELS, isLoading: false, error: null, refetch: () => {} };
   return function Wrapper({ children }: { children: ReactNode }) {
     return (
       <ModelRegistryContext.Provider value={state}>

package/src/session/group-sessions.ts

@@ -1,4 +1,5 @@
 import type { Session } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
+import type { SearchResult } from "@stigmer/protos/ai/stigmer/search/v1/io_pb";
 import { timestampDate } from "@bufbuild/protobuf/wkt";
 
 /** A time-based group of sessions produced by {@link groupSessionsByTime}. */
@@ -9,11 +10,24 @@ export interface SessionGroup {
   readonly sessions: readonly Session[];
 }
 
+/** A time-based group of search results produced by {@link groupSearchResultsByTime}. */
+export interface SearchResultGroup {
+  /** Display label for this group (e.g. "Today", "Yesterday"). */
+  readonly label: string;
+  /** Search results belonging to this group, in their original input order. */
+  readonly entries: readonly SearchResult[];
+}
+
 interface Bucket {
   label: string;
   sessions: Session[];
 }
 
+interface SearchResultBucket {
+  label: string;
+  entries: SearchResult[];
+}
+
 /**
  * Groups sessions by their creation timestamp into time-based buckets:
  * "Today", "Yesterday", "Previous 7 Days", "Previous 30 Days", "Older".
@@ -91,6 +105,57 @@ export function groupSessionsByTime(
   return buckets.filter((b) => b.sessions.length > 0);
 }
 
+/**
+ * Groups SearchResult entries by their `createdAt` timestamp into time-based
+ * buckets, identical to {@link groupSessionsByTime} but for lightweight
+ * search results.
+ *
+ * @param entries - SearchResult entries (from SearchService session search).
+ * @param now - Reference time for grouping; defaults to current time.
+ */
+export function groupSearchResultsByTime(
+  entries: readonly SearchResult[],
+  now?: Date,
+): readonly SearchResultGroup[] {
+  const ref = now ?? new Date();
+  const todayStart = startOfDay(ref);
+  const yesterdayStart = addDays(todayStart, -1);
+  const sevenDaysAgo = addDays(todayStart, -6);
+  const thirtyDaysAgo = addDays(todayStart, -29);
+
+  const buckets: SearchResultBucket[] = [
+    { label: "Today", entries: [] },
+    { label: "Yesterday", entries: [] },
+    { label: "Previous 7 Days", entries: [] },
+    { label: "Previous 30 Days", entries: [] },
+    { label: "Older", entries: [] },
+  ];
+
+  for (const entry of entries) {
+    const ts = entry.createdAt;
+    const date = ts ? timestampDate(ts) : null;
+
+    if (!date) {
+      buckets[buckets.length - 1].entries.push(entry);
+      continue;
+    }
+
+    if (date >= todayStart) {
+      buckets[0].entries.push(entry);
+    } else if (date >= yesterdayStart) {
+      buckets[1].entries.push(entry);
+    } else if (date >= sevenDaysAgo) {
+      buckets[2].entries.push(entry);
+    } else if (date >= thirtyDaysAgo) {
+      buckets[3].entries.push(entry);
+    } else {
+      buckets[4].entries.push(entry);
+    }
+  }
+
+  return buckets.filter((b) => b.entries.length > 0);
+}
+
 function startOfDay(date: Date): Date {
   const d = new Date(date);
   d.setHours(0, 0, 0, 0);

package/src/session/index.ts

@@ -76,8 +76,14 @@ export type {
   DraftParams,
 } from "./draft";
 
-export { groupSessionsByTime } from "./group-sessions";
-export type { SessionGroup } from "./group-sessions";
+export { groupSessionsByTime, groupSearchResultsByTime } from "./group-sessions";
+export type { SessionGroup, SearchResultGroup } from "./group-sessions";
+
+export { useSessionSearch } from "./useSessionSearch";
+export type {
+  UseSessionSearchOptions,
+  UseSessionSearchReturn,
+} from "./useSessionSearch";
 
 // Session utilities (re-exported from @stigmer/sdk)
 export { PENDING_SUBJECT, resolvedSubject } from "@stigmer/sdk";

package/src/session/session-spec-converters.ts

@@ -0,0 +1,86 @@
+import type { Session } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
+import type {
+  McpServerUsageInput,
+  ResourceRef,
+  WorkspaceEntryInput,
+} from "@stigmer/sdk";
+
+/**
+ * Convert proto workspace entries back to SDK input format.
+ *
+ * Used by `useSessionConversation` (session update with replace semantics)
+ * and `useSessionPageFlow` (hydrating composer state from a loaded session).
+ */
+export function specWorkspaceToInput(
+  spec: Session["spec"],
+): WorkspaceEntryInput[] | undefined {
+  return spec?.workspaceEntries?.map((e): WorkspaceEntryInput => {
+    if (e.source?.source.case === "gitRepo") {
+      const v = e.source.source.value;
+      return {
+        name: e.name || undefined,
+        source: {
+          gitRepo: {
+            url: v.url,
+            branch: v.branch || undefined,
+            commit: v.commit || undefined,
+            depth: v.depth || undefined,
+          },
+        },
+      };
+    }
+    if (e.source?.source.case === "localPath") {
+      return {
+        name: e.name || undefined,
+        source: {
+          localPath: { path: e.source.source.value.path || undefined },
+        },
+      };
+    }
+    return { name: e.name || undefined, source: {} };
+  });
+}
+
+/**
+ * Convert proto MCP server usages back to SDK input format.
+ *
+ * Used by `useSessionConversation` (session update with replace semantics)
+ * and `useSessionPageFlow` (hydrating composer state from a loaded session).
+ */
+export function specMcpUsagesToInput(
+  spec: Session["spec"],
+): McpServerUsageInput[] | undefined {
+  return spec?.mcpServerUsages?.map((u) => ({
+    mcpServerRef: {
+      org: u.mcpServerRef?.org ?? "",
+      slug: u.mcpServerRef?.slug ?? "",
+      version: u.mcpServerRef?.version || undefined,
+      kind: u.mcpServerRef?.kind,
+    },
+    enabledTools: u.enabledTools?.length ? [...u.enabledTools] : undefined,
+    toolApprovalOverrides: u.toolApprovalOverrides?.length
+      ? u.toolApprovalOverrides.map((o) => ({
+          toolName: o.toolName || undefined,
+          requiresApproval: o.requiresApproval || undefined,
+          message: o.message || undefined,
+        }))
+      : undefined,
+  }));
+}
+
+/**
+ * Convert proto skill references back to SDK input format.
+ *
+ * Used by `useSessionConversation` (session update with replace semantics)
+ * and `useSessionPageFlow` (hydrating composer state from a loaded session).
+ */
+export function specSkillRefsToInput(
+  spec: Session["spec"],
+): ResourceRef[] | undefined {
+  return spec?.skillRefs?.map((r) => ({
+    org: r.org ?? "",
+    slug: r.slug ?? "",
+    version: r.version || undefined,
+    kind: r.kind,
+  }));
+}

package/src/session/useSessionConversation.ts

@@ -24,6 +24,11 @@ import { useSubmitApproval } from "../execution/useSubmitApproval";
 import { useSession } from "./useSession";
 import { useSessionExecutions } from "./useSessionExecutions";
 import { useUpdateSession } from "./useUpdateSession";
+import {
+  specWorkspaceToInput,
+  specMcpUsagesToInput,
+  specSkillRefsToInput,
+} from "./session-spec-converters";
 
 /**
  * Options for {@link UseSessionConversationReturn.sendFollowUp}.
@@ -479,67 +484,3 @@ function buildUpdateInput(
   };
 }
 
-/** Convert proto workspace entries back to SDK input format. */
-function specWorkspaceToInput(
-  spec: Session["spec"],
-): WorkspaceEntryInput[] | undefined {
-  return spec?.workspaceEntries?.map((e): WorkspaceEntryInput => {
-    if (e.source?.source.case === "gitRepo") {
-      const v = e.source.source.value;
-      return {
-        name: e.name || undefined,
-        source: {
-          gitRepo: {
-            url: v.url,
-            branch: v.branch || undefined,
-            commit: v.commit || undefined,
-            depth: v.depth || undefined,
-          },
-        },
-      };
-    }
-    if (e.source?.source.case === "localPath") {
-      return {
-        name: e.name || undefined,
-        source: {
-          localPath: { path: e.source.source.value.path || undefined },
-        },
-      };
-    }
-    return { name: e.name || undefined, source: {} };
-  });
-}
-
-/** Convert proto MCP server usages back to SDK input format. */
-function specMcpUsagesToInput(
-  spec: Session["spec"],
-): McpServerUsageInput[] | undefined {
-  return spec?.mcpServerUsages?.map((u) => ({
-    mcpServerRef: {
-      org: u.mcpServerRef?.org ?? "",
-      slug: u.mcpServerRef?.slug ?? "",
-      version: u.mcpServerRef?.version || undefined,
-      kind: u.mcpServerRef?.kind,
-    },
-    enabledTools: u.enabledTools?.length ? [...u.enabledTools] : undefined,
-    toolApprovalOverrides: u.toolApprovalOverrides?.length
-      ? u.toolApprovalOverrides.map((o) => ({
-          toolName: o.toolName || undefined,
-          requiresApproval: o.requiresApproval || undefined,
-          message: o.message || undefined,
-        }))
-      : undefined,
-  }));
-}
-
-/** Convert proto skill references back to SDK input format. */
-function specSkillRefsToInput(
-  spec: Session["spec"],
-): ResourceRef[] | undefined {
-  return spec?.skillRefs?.map((r) => ({
-    org: r.org ?? "",
-    slug: r.slug ?? "",
-    version: r.version || undefined,
-    kind: r.kind,
-  }));
-}

package/src/session/useSessionPageFlow.ts

@@ -13,6 +13,7 @@ import { Harness } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
 import { useSessionConversation, type UseSessionConversationReturn } from "./useSessionConversation";
 import { useAgentRefFromSession } from "./useAgentRefFromSession";
 import { usePersistedModel, type UsePersistedModelReturn } from "./usePersistedModel";
+import { specMcpUsagesToInput, specSkillRefsToInput } from "./session-spec-converters";
 
 /**
  * Well-known Daytona sandbox workspace root. Used as the SDK safety-net
@@ -55,6 +56,11 @@ export interface UseSessionPageFlowReturn {
   readonly resolution: AgentResolution | null;
   /** Update the agent resolution. */
   readonly setResolution: (r: AgentResolution | null) => void;
+  /**
+   * `true` when the session's agent is the org's default agent.
+   * Used to render the agent chip as non-removable in the composer.
+   */
+  readonly isDefaultAgent: boolean;
 
   /** Active MCP server configurations for follow-ups. */
   readonly mcpServerUsages: McpServerUsageInput[];
@@ -177,31 +183,33 @@ export function useSessionPageFlow(
 
   const [agentRef, setAgentRef] = useState<ResourceRef | null>(null);
   const [resolution, setResolution] = useState<AgentResolution | null>(null);
+  const [isDefaultAgent, setIsDefaultAgent] = useState(false);
   const [agentInitDone, setAgentInitDone] = useState(false);
 
   if (!agentInitDone && derivedAgentRef && sessionInstanceId && !isDefaultAgentLoading) {
     setAgentInitDone(true);
+    setAgentRef(derivedAgentRef);
+    setResolution({ mode: "saved", instanceId: sessionInstanceId });
 
     const isDefault =
       defaultAgent &&
       derivedAgentRef.org === defaultAgent.metadata?.org &&
       derivedAgentRef.slug === defaultAgent.metadata?.slug;
-
-    if (!isDefault) {
-      setAgentRef(derivedAgentRef);
-      setResolution({ mode: "saved", instanceId: sessionInstanceId });
-    }
+    setIsDefaultAgent(!!isDefault);
   }
 
   // -------------------------------------------------------------------------
-  // Workspace — sync entries from session on first load
+  // Session spec sync — hydrate workspace, MCP servers, and skills on first load
   // -------------------------------------------------------------------------
 
   useEffect(() => {
     if (!conv.session || initialSyncDone.current) return;
     initialSyncDone.current = true;
 
-    const protoEntries = conv.session.spec?.workspaceEntries ?? [];
+    const spec = conv.session.spec;
+
+    // Workspace entries
+    const protoEntries = spec?.workspaceEntries ?? [];
     for (const entry of protoEntries) {
       if (entry.source?.source.case === "gitRepo") {
         const { url, branch } = entry.source.source.value;
@@ -210,6 +218,18 @@ export function useSessionPageFlow(
         workspace.addLocalPath(entry.source.source.value.path);
       }
     }
+
+    // MCP server usages
+    const mcpInputs = specMcpUsagesToInput(spec);
+    if (mcpInputs?.length) {
+      setMcpServerUsages(mcpInputs);
+    }
+
+    // Skill references
+    const skillInputs = specSkillRefsToInput(spec);
+    if (skillInputs?.length) {
+      setSkillRefs(skillInputs);
+    }
   }, [conv.session, workspace]);
 
   // -------------------------------------------------------------------------
@@ -290,6 +310,7 @@ export function useSessionPageFlow(
     setAgentRef,
     resolution,
     setResolution,
+    isDefaultAgent,
     mcpServerUsages,
     setMcpServerUsages,
     skillRefs,