@stigmer/react 0.0.53 → 0.0.54

package/src/execution/__tests__/file-path-resolver.test.ts

@@ -0,0 +1,295 @@
+import { describe, it, expect } from "vitest";
+import { create } from "@bufbuild/protobuf";
+import {
+  WorkspaceEntrySchema,
+  WorkspaceSourceSchema,
+  GitRepoSourceSchema,
+  LocalPathSourceSchema,
+} from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
+import type { WorkspaceEntry } from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
+import {
+  classifyPath,
+  resolveGitBrowseUrl,
+  resolvePathAction,
+} from "../file-path-resolver";
+
+// ---------------------------------------------------------------------------
+// Factory helpers
+// ---------------------------------------------------------------------------
+
+function gitEntry(name: string, url: string, branch = "main"): WorkspaceEntry {
+  return create(WorkspaceEntrySchema, {
+    name,
+    source: create(WorkspaceSourceSchema, {
+      source: {
+        case: "gitRepo",
+        value: create(GitRepoSourceSchema, { url, branch, commit: "" }),
+      },
+    }),
+  });
+}
+
+function localEntry(name: string, path: string): WorkspaceEntry {
+  return create(WorkspaceEntrySchema, {
+    name,
+    source: create(WorkspaceSourceSchema, {
+      source: {
+        case: "localPath",
+        value: create(LocalPathSourceSchema, { path }),
+      },
+    }),
+  });
+}
+
+// ---------------------------------------------------------------------------
+// classifyPath
+// ---------------------------------------------------------------------------
+
+describe("classifyPath", () => {
+  it("classifies platform paths", () => {
+    expect(classifyPath(".stigmer/skills/foo.md")).toEqual({
+      kind: "platform",
+      subpath: "skills/foo.md",
+    });
+  });
+
+  it("classifies bare .stigmer directory", () => {
+    expect(classifyPath(".stigmer")).toEqual({
+      kind: "platform",
+      subpath: "",
+    });
+  });
+
+  it("strips leading slashes from platform paths", () => {
+    expect(classifyPath("/.stigmer/inputs/bar")).toEqual({
+      kind: "platform",
+      subpath: "inputs/bar",
+    });
+  });
+
+  it("classifies workspace paths", () => {
+    expect(classifyPath("src/main.go")).toEqual({
+      kind: "workspace",
+      remainder: "src/main.go",
+    });
+  });
+
+  it("strips leading slashes from workspace paths", () => {
+    expect(classifyPath("/src/main.go")).toEqual({
+      kind: "workspace",
+      remainder: "src/main.go",
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveGitBrowseUrl
+// ---------------------------------------------------------------------------
+
+describe("resolveGitBrowseUrl", () => {
+  it("constructs a correct GitHub blob URL", () => {
+    expect(
+      resolveGitBrowseUrl(
+        "https://github.com/acme/app.git",
+        "main",
+        "",
+        "src/index.ts",
+      ),
+    ).toBe("https://github.com/acme/app/blob/main/src/index.ts");
+  });
+
+  it("prefers commit over branch", () => {
+    expect(
+      resolveGitBrowseUrl(
+        "https://github.com/acme/app.git",
+        "main",
+        "abc123",
+        "README.md",
+      ),
+    ).toBe("https://github.com/acme/app/blob/abc123/README.md");
+  });
+
+  it("falls back to HEAD when both branch and commit are empty", () => {
+    expect(
+      resolveGitBrowseUrl(
+        "https://github.com/acme/app.git",
+        "",
+        "",
+        "README.md",
+      ),
+    ).toBe("https://github.com/acme/app/blob/HEAD/README.md");
+  });
+
+  it("returns null for non-GitHub hosts", () => {
+    expect(
+      resolveGitBrowseUrl(
+        "https://gitlab.com/acme/app.git",
+        "main",
+        "",
+        "src/main.go",
+      ),
+    ).toBeNull();
+  });
+
+  it("returns null for invalid URLs", () => {
+    expect(
+      resolveGitBrowseUrl("not-a-url", "main", "", "file.txt"),
+    ).toBeNull();
+  });
+
+  it("strips duplicate org/repo prefix from relPath", () => {
+    expect(
+      resolveGitBrowseUrl(
+        "https://github.com/plantonhq/agent-fleet.git",
+        "main",
+        "",
+        "plantonhq/agent-fleet/mcp-servers/mcp-server-planton.yaml",
+      ),
+    ).toBe(
+      "https://github.com/plantonhq/agent-fleet/blob/main/mcp-servers/mcp-server-planton.yaml",
+    );
+  });
+
+  it("does not strip when relPath shares a partial prefix", () => {
+    expect(
+      resolveGitBrowseUrl(
+        "https://github.com/acme/app.git",
+        "main",
+        "",
+        "acme/other-thing/file.txt",
+      ),
+    ).toBe("https://github.com/acme/app/blob/main/acme/other-thing/file.txt");
+  });
+
+  it("handles clone URLs without .git suffix", () => {
+    expect(
+      resolveGitBrowseUrl(
+        "https://github.com/acme/app",
+        "main",
+        "",
+        "src/lib.rs",
+      ),
+    ).toBe("https://github.com/acme/app/blob/main/src/lib.rs");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolvePathAction — integration (exercises matchWorkspaceEntry internally)
+// ---------------------------------------------------------------------------
+
+describe("resolvePathAction", () => {
+  it("returns copy for empty path", () => {
+    const result = resolvePathAction("", []);
+    expect(result.action).toBe("copy");
+  });
+
+  it("returns copy for platform paths", () => {
+    const entries = [gitEntry("app", "https://github.com/acme/app.git")];
+    const result = resolvePathAction(".stigmer/skills/foo.md", entries);
+    expect(result.action).toBe("copy");
+  });
+
+  it("returns copy when no workspace entries", () => {
+    const result = resolvePathAction("src/main.go", []);
+    expect(result.action).toBe("copy");
+  });
+
+  describe("single git workspace entry", () => {
+    const entries = [
+      gitEntry("agent-fleet", "https://github.com/plantonhq/agent-fleet.git"),
+    ];
+
+    it("produces a GitHub link for a relative path", () => {
+      const result = resolvePathAction(
+        "mcp-servers/mcp-server-planton.yaml",
+        entries,
+      );
+      expect(result).toEqual({
+        action: "link",
+        url: "https://github.com/plantonhq/agent-fleet/blob/main/mcp-servers/mcp-server-planton.yaml",
+        tooltip: "Open on GitHub",
+      });
+    });
+  });
+
+  describe("multiple git workspace entries — first-segment match", () => {
+    const entries = [
+      gitEntry(
+        "mcp-server-planton",
+        "https://github.com/plantonhq/mcp-server-planton.git",
+      ),
+      gitEntry(
+        "agent-fleet",
+        "https://github.com/plantonhq/agent-fleet.git",
+      ),
+    ];
+
+    it("matches entry by first path segment and strips it", () => {
+      const result = resolvePathAction(
+        "agent-fleet/mcp-servers/mcp-server-planton.yaml",
+        entries,
+      );
+      expect(result).toEqual({
+        action: "link",
+        url: "https://github.com/plantonhq/agent-fleet/blob/main/mcp-servers/mcp-server-planton.yaml",
+        tooltip: "Open on GitHub",
+      });
+    });
+  });
+
+  describe("multiple git workspace entries — deep segment match (bug fix)", () => {
+    const entries = [
+      gitEntry(
+        "mcp-server-planton",
+        "https://github.com/plantonhq/mcp-server-planton.git",
+      ),
+      gitEntry(
+        "agent-fleet",
+        "https://github.com/plantonhq/agent-fleet.git",
+      ),
+    ];
+
+    it("matches entry by deeper segment when org prefix is present", () => {
+      const result = resolvePathAction(
+        "plantonhq/agent-fleet/mcp-servers/mcp-server-planton.yaml",
+        entries,
+      );
+      expect(result).toEqual({
+        action: "link",
+        url: "https://github.com/plantonhq/agent-fleet/blob/main/mcp-servers/mcp-server-planton.yaml",
+        tooltip: "Open on GitHub",
+      });
+    });
+  });
+
+  describe("fallback to first entry when no segment matches", () => {
+    const entries = [
+      gitEntry("my-app", "https://github.com/acme/my-app.git"),
+      gitEntry("my-lib", "https://github.com/acme/my-lib.git"),
+    ];
+
+    it("falls back to entries[0] with full path as relPath", () => {
+      const result = resolvePathAction("unknown/path/file.txt", entries);
+      expect(result).toEqual({
+        action: "link",
+        url: "https://github.com/acme/my-app/blob/main/unknown/path/file.txt",
+        tooltip: "Open on GitHub",
+      });
+    });
+  });
+
+  describe("local path workspace entry", () => {
+    const entries = [
+      localEntry("my-app", "/Users/dev/projects/my-app"),
+    ];
+
+    it("joins local path for copy action", () => {
+      const result = resolvePathAction("src/main.go", entries);
+      expect(result).toEqual({
+        action: "copy",
+        value: "/Users/dev/projects/my-app/src/main.go",
+        tooltip: "Copy path",
+      });
+    });
+  });
+});

package/src/execution/file-path-resolver.ts

@@ -62,7 +62,15 @@ export function resolveGitBrowseUrl(
   if (!repoPath) return null;
 
   const ref = commit || branch || "HEAD";
-  const cleanRelPath = relPath.replace(/^\/+/, "");
+  let cleanRelPath = relPath.replace(/^\/+/, "");
+
+  // Guard against relPath that accidentally duplicates the org/repo
+  // already encoded in gitUrl (e.g. relPath = "acme/app/src/main.go"
+  // when repoPath is "acme/app"). Strip the redundant prefix so the
+  // final URL doesn't contain the repo path twice.
+  if (cleanRelPath.startsWith(repoPath + "/")) {
+    cleanRelPath = cleanRelPath.slice(repoPath.length + 1);
+  }
 
   return `https://github.com/${repoPath}/blob/${ref}/${cleanRelPath}`;
 }
@@ -83,9 +91,9 @@ export type ResolvedPathAction =
  * 1. **Platform paths** (`.stigmer/` prefix) → copy raw path.
  * 2. **Workspace paths** → match against workspace entries:
  *    - Single entry: treat path as relative to that entry.
- *    - Multiple entries: match first path segment against entry names.
- *      Unmatched segments fall back to the first entry (optimistic —
- *      single-workspace sessions are the common case).
+ *    - Multiple entries: scan path segments for an entry name match
+ *      (handles org-prefixed paths like `plantonhq/agent-fleet/...`).
+ *      Unmatched paths fall back to the first entry.
  * 3. **Git source** → construct GitHub blob URL.
  * 4. **Local source** → join with absolute local path for copy.
  * 5. **Fallback** → copy the raw path.
@@ -139,8 +147,11 @@ export function resolvePathAction(
 /**
  * Matches a workspace-relative path against entries. With a single
  * entry the path is used as-is. With multiple entries the first path
- * segment is tested against entry names; unmatched paths fall back to
- * the first entry (same strategy as the CLI).
+ * segment is tested against entry names. When the first segment
+ * doesn't match, deeper segments are scanned — this handles tool-call
+ * paths that embed an org prefix (e.g. `plantonhq/agent-fleet/...`
+ * where the entry name is `agent-fleet`). Unmatched paths fall back
+ * to the first entry.
  */
 function matchWorkspaceEntry(
   relPath: string,
@@ -150,13 +161,14 @@ function matchWorkspaceEntry(
     return { entry: entries[0], relPath };
   }
 
-  const slashIdx = relPath.indexOf("/");
-  const firstSegment = slashIdx >= 0 ? relPath.slice(0, slashIdx) : relPath;
+  const segments = relPath.split("/");
 
-  for (const entry of entries) {
-    if (entry.name === firstSegment) {
-      const rest = slashIdx >= 0 ? relPath.slice(slashIdx + 1) : "";
-      return { entry, relPath: rest };
+  for (let i = 0; i < segments.length; i++) {
+    for (const entry of entries) {
+      if (entry.name === segments[i]) {
+        const rest = segments.slice(i + 1).join("/");
+        return { entry, relPath: rest };
+      }
     }
   }
 

package/src/execution/index.ts

@@ -19,6 +19,12 @@ export type { UseExecutionArtifactsReturn } from "./useExecutionArtifacts";
 export { useArtifactContent } from "./useArtifactContent";
 export type { UseArtifactContentReturn } from "./useArtifactContent";
 
+export { useWorkspaceWriteBacks } from "./useWorkspaceWriteBacks";
+export type { UseWorkspaceWriteBacksReturn } from "./useWorkspaceWriteBacks";
+
+export { WriteBackCard } from "./WriteBackCard";
+export type { WriteBackCardProps } from "./WriteBackCard";
+
 export {
   isTextArtifact,
   isArtifactExpired,
@@ -104,6 +110,9 @@ export type { ArtifactPreviewModalProps } from "./ArtifactPreviewModal";
 export { ArtifactsWidget } from "./ArtifactsWidget";
 export type { ArtifactsWidgetProps } from "./ArtifactsWidget";
 
+export { WriteBacksWidget } from "./WriteBacksWidget";
+export type { WriteBacksWidgetProps } from "./WriteBacksWidget";
+
 export {
   resolveToolCategory,
   extractPrimaryArg,
@@ -118,6 +127,10 @@ export type { FilePathLinkProps } from "./FilePathLink";
 export { FilePathContext } from "./FilePathContext";
 export type { FilePathContextValue } from "./FilePathContext";
 
+export { normalizeSandboxPaths } from "./sandbox-path-normalizer";
+export { SandboxContext, useSandboxNormalize } from "./SandboxContext";
+export type { SandboxContextValue } from "./SandboxContext";
+
 export { classifyPath, resolveGitBrowseUrl, resolvePathAction } from "./file-path-resolver";
 export type { PathClassification, ResolvedPathAction } from "./file-path-resolver";
 

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]);
+}