@stigmer/react 0.0.53 → 0.0.55

package/src/execution/sandbox-path-normalizer.ts

@@ -0,0 +1,80 @@
+/**
+ * Display-time normalization for sandbox workspace paths.
+ *
+ * Mirrors the Python `humanize_sandbox_paths` in
+ * `graphton.core.backends.platform_mount` — same semantics, same
+ * replacement order.  The SDK version acts as a safety net for
+ * historical data (persisted before backend humanization was added)
+ * and streaming edge cases.
+ *
+ * @module
+ */
+
+/**
+ * Replace absolute sandbox workspace paths with workspace-relative
+ * display paths.
+ *
+ * Performs three ordered replacements:
+ *
+ * 1. `workspaceRoot + "/"` → empty string (makes paths workspace-relative)
+ * 2. `workspaceRoot` (exact) → `"."` (the workspace root itself)
+ * 3. Parent of `workspaceRoot` (sandbox home) → `"~"` (Unix convention)
+ *
+ * Returns `text` unchanged when `workspaceRoot` is empty.
+ *
+ * @example
+ * ```ts
+ * normalizeSandboxPaths(
+ *   "ls /home/daytona/workspace/plantonhq/",
+ *   "/home/daytona/workspace",
+ * );
+ * // => "ls plantonhq/"
+ *
+ * normalizeSandboxPaths(
+ *   "cd /home/daytona/workspace && ls",
+ *   "/home/daytona/workspace",
+ * );
+ * // => "cd . && ls"
+ *
+ * normalizeSandboxPaths(
+ *   "cat /home/daytona/.bashrc",
+ *   "/home/daytona/workspace",
+ * );
+ * // => "cat ~/.bashrc"
+ * ```
+ */
+export function normalizeSandboxPaths(
+  text: string,
+  workspaceRoot: string,
+): string {
+  if (!text || !workspaceRoot) return text;
+
+  const wsRoot = workspaceRoot.replace(/\/+$/, "");
+
+  // 1) Strip workspace root prefix (with trailing slash) → workspace-relative
+  text = replaceAll(text, wsRoot + "/", "");
+
+  // 2) Replace bare workspace root → "."
+  text = replaceAll(text, wsRoot, ".");
+
+  // 3) Replace sandbox home prefix → "~"
+  const lastSlash = wsRoot.lastIndexOf("/");
+  if (lastSlash > 0) {
+    const sandboxHome = wsRoot.slice(0, lastSlash);
+    text = replaceAll(text, sandboxHome + "/", "~/");
+    text = replaceAll(text, sandboxHome, "~");
+  }
+
+  return text;
+}
+
+function replaceAll(text: string, search: string, replacement: string): string {
+  if (!search) return text;
+  let result = text;
+  let idx = result.indexOf(search);
+  while (idx !== -1) {
+    result = result.slice(0, idx) + replacement + result.slice(idx + search.length);
+    idx = result.indexOf(search, idx + replacement.length);
+  }
+  return result;
+}

package/src/execution/useArtifactContent.ts

@@ -80,6 +80,10 @@ export interface UseArtifactContentReturn {
  * @param storageKey - Storage key from `ExecutionArtifact.storageKey`, or `null` to skip.
  * @param entryPath - For directory artifacts: relative path of a file within
  *   the archive to extract. `null` returns the full artifact (existing behavior).
+ * @param contentHash - SHA-256 hex digest from `ExecutionArtifact.contentHash`.
+ *   When the same file is overwritten during execution, the `storageKey` stays
+ *   stable but `contentHash` changes, triggering a re-fetch so the UI never
+ *   shows stale content. Pass `undefined` or omit for backwards compatibility.
  *
  * @see useExecutionArtifacts — extracts artifact metadata from an execution
  * @see isTextArtifact — heuristic for whether content is fetchable as text
@@ -88,6 +92,7 @@ export function useArtifactContent(
   executionId: string | null,
   storageKey: string | null,
   entryPath?: string | null,
+  contentHash?: string,
 ): UseArtifactContentReturn {
   const stigmer = useStigmer();
 
@@ -150,7 +155,7 @@ export function useArtifactContent(
     return () => {
       cancelled.current = true;
     };
-  }, [executionId, storageKey, entryPath, stigmer, fetchKey]);
+  }, [executionId, storageKey, entryPath, contentHash, stigmer, fetchKey]);
 
   return { content, contentType, isTruncated, isLoading, error, refetch };
 }

package/src/execution/useWorkspaceWriteBacks.ts

@@ -0,0 +1,56 @@
+"use client";
+
+import { useMemo } from "react";
+import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import type { WorkspaceWriteBack } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/writeback_pb";
+
+export interface UseWorkspaceWriteBacksReturn {
+  /** Write-back outcomes for git-backed workspace entries, ordered by workspace entry name. */
+  readonly writeBacks: readonly WorkspaceWriteBack[];
+  /** `true` when the execution has at least one write-back entry. */
+  readonly hasWriteBacks: boolean;
+  /** Total number of write-back entries. */
+  readonly writeBackCount: number;
+}
+
+/**
+ * Pure derivation hook that extracts workspace write-back data from an
+ * {@link AgentExecution} snapshot.
+ *
+ * Follows the same `useMemo`-based derivation pattern as
+ * {@link useExecutionArtifacts}: no side effects, no data fetching.
+ * The execution object (typically from {@link useExecutionStream}) is
+ * the single input.
+ *
+ * Returns an empty array when the execution is `null` or has no
+ * write-backs, eliminating null-checking at every consumer call site.
+ *
+ * Each `WorkspaceWriteBack` entry corresponds to a git-backed workspace
+ * entry where the platform detected file changes and ran the automatic
+ * branch/commit/push/PR workflow.
+ *
+ * @example
+ * ```tsx
+ * const { execution } = useExecutionStream(executionId);
+ * const { writeBacks, hasWriteBacks } = useWorkspaceWriteBacks(execution);
+ *
+ * if (hasWriteBacks) {
+ *   writeBacks.forEach((wb) => console.log(wb.workspaceEntryName, wb.pullRequestUrl));
+ * }
+ * ```
+ *
+ * @see useExecutionArtifacts — similar derivation hook for artifacts
+ */
+export function useWorkspaceWriteBacks(
+  execution: AgentExecution | null,
+): UseWorkspaceWriteBacksReturn {
+  return useMemo(() => {
+    const writeBacks = execution?.status?.workspaceWriteBacks ?? [];
+
+    return {
+      writeBacks,
+      hasWriteBacks: writeBacks.length > 0,
+      writeBackCount: writeBacks.length,
+    };
+  }, [execution]);
+}