npm - @cursor/july - Versions diffs - 0.1.75 → 0.1.76 - Mend

@cursor/july 0.1.75 → 0.1.76

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/dist/internal/authored-alias-hooks.d.ts +12 -0
package/dist/internal/authored-alias-hooks.d.ts.map +1 -1
package/dist/internal/authored-alias-hooks.js +60 -8
package/dist/internal/authored-loaders.d.ts +5 -3
package/dist/internal/authored-loaders.d.ts.map +1 -1
package/dist/internal/authored-loaders.js +13 -4
package/dist/internal/deployment-scm-event-stream.js +4 -4
package/dist/internal/review-comments.d.ts +62 -0
package/dist/internal/review-comments.d.ts.map +1 -1
package/dist/internal/review-comments.js +199 -0
package/dist/playground/assets/index-Bfwz2yLN.css +1 -0
package/dist/playground/index.html +2 -2
package/package.json +1 -1
package/src/internal/authored-alias-hooks.ts +75 -7
package/src/internal/authored-loaders.ts +15 -4
package/src/internal/deployment-scm-event-stream.ts +4 -4
package/src/internal/review-comments.ts +286 -0
package/dist/playground/assets/index-BrSd5vff.css +0 -1
/package/dist/playground/assets/{index-BJy9UJrF.js → index-BWqjJcRo.js} +0 -0

package/dist/playground/index.html CHANGED Viewed

@@ -8,8 +8,8 @@
     />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>agent-serve playground</title>
-    <script type="module" crossorigin src="./assets/index-BJy9UJrF.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-BrSd5vff.css">
+    <script type="module" crossorigin src="./assets/index-BWqjJcRo.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-Bfwz2yLN.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@cursor/july",
-  "version": "0.1.75",
+  "version": "0.1.76",
   "description": "(early alpha) Filesystem-first framework for defining Cursor agents as markdown and TypeScript and serving them over channels with the Cursor SDK.",
   "license": "SEE LICENSE IN LICENSE.md",
   "repository": {

package/src/internal/authored-alias-hooks.ts CHANGED Viewed

@@ -14,16 +14,29 @@
  *   project's own node_modules; `fallbackAliases` only apply when that
  *   fails (npx/global installs, projects without a local dependency), so a
  *   real install in the user's project keeps precedence.
+ *
+ * A third case is first-party factory agents that relative-import this
+ * package's `src/` from a monorepo checkout. Hosted engines `npm install`
+ * only the agent directory, so files under `packages/agent-serve/src` have
+ * no `node_modules`. Bare specifiers from that tree (`zod`, octokit, …)
+ * retry against the running `@cursor/july` package.json, which does.
  */
 // Null-prototype copies so specifiers like "constructor" or "__proto__"
 // can never resolve to inherited Object.prototype members.
 let directAliases = toNullProtoMap({});
 let fallbackAliases = toNullProtoMap({});
+let sourceTreeFallbackParentURL: string | undefined;
 export interface AuthoredAliasHookData {
   directAliases: Record<string, string>;
   fallbackAliases: Record<string, string>;
+  /**
+   * `file:` URL of the running `@cursor/july` package.json. Bare imports
+   * from monorepo `packages/agent-serve/` source retry against this parent
+   * when the source tree has no `node_modules` (hosted factory engines).
+   */
+  sourceTreeFallbackParentURL?: string;
 }
 function toNullProtoMap(
@@ -35,6 +48,9 @@ function toNullProtoMap(
 export function initialize(data: AuthoredAliasHookData): void {
   directAliases = toNullProtoMap(data.directAliases);
   fallbackAliases = toNullProtoMap(data.fallbackAliases);
+  const parent = data.sourceTreeFallbackParentURL;
+  sourceTreeFallbackParentURL =
+    typeof parent === "string" && parent !== "" ? parent : undefined;
 }
 interface ResolveResult {
@@ -58,12 +74,64 @@ export function resolve(
     return { url: direct, shortCircuit: true };
   }
   const fallback = fallbackAliases[specifier];
-  if (fallback === undefined) {
-    // Not ours: pass through with no promise/try-catch overhead. This hook
-    // runs on every module resolution in the process.
-    return nextResolve(specifier, context);
+  if (fallback !== undefined) {
+    return Promise.resolve()
+      .then(() => nextResolve(specifier, context))
+      .catch(() => ({ url: fallback, shortCircuit: true }));
+  }
+  if (
+    sourceTreeFallbackParentURL !== undefined &&
+    isBarePackageSpecifier(specifier) &&
+    isMonorepoAgentServeSource(parentURLOf(context))
+  ) {
+    const retryParent = sourceTreeFallbackParentURL;
+    return Promise.resolve()
+      .then(() => nextResolve(specifier, context))
+      .catch(() => nextResolve(specifier, withParentURL(context, retryParent)));
+  }
+  // Not ours: pass through with no promise/try-catch overhead. This hook
+  // runs on every module resolution in the process.
+  return nextResolve(specifier, context);
+}
+function parentURLOf(context: unknown): string | undefined {
+  if (context === null || typeof context !== "object") {
+    return undefined;
+  }
+  const parentURL = (context as { parentURL?: unknown }).parentURL;
+  return typeof parentURL === "string" ? parentURL : undefined;
+}
+function withParentURL(context: unknown, parentURL: string): unknown {
+  if (context !== null && typeof context === "object") {
+    return { ...(context as Record<string, unknown>), parentURL };
+  }
+  return { parentURL };
+}
+function isBarePackageSpecifier(specifier: string): boolean {
+  if (specifier.length === 0) {
+    return false;
+  }
+  const first = specifier[0];
+  if (first === "." || first === "/" || first === "\\") {
+    return false;
+  }
+  return !(
+    specifier.startsWith("node:") ||
+    specifier.startsWith("file:") ||
+    specifier.startsWith("data:") ||
+    specifier.startsWith("http:") ||
+    specifier.startsWith("https:")
+  );
+}
+function isMonorepoAgentServeSource(parentURL: string | undefined): boolean {
+  if (parentURL === undefined) {
+    return false;
   }
-  return Promise.resolve()
-    .then(() => nextResolve(specifier, context))
-    .catch(() => ({ url: fallback, shortCircuit: true }));
+  return (
+    parentURL.includes("/packages/agent-serve/") &&
+    !parentURL.includes("/node_modules/")
+  );
 }

package/src/internal/authored-loaders.ts CHANGED Viewed

@@ -11,9 +11,11 @@
  * imports of the framework resolve against the running package: the
  * historical `@anysphere/agent-serve[/x]` name always, and
  * `@cursor/july[/x]` / `@cursor/agentkit[/x]` as fallbacks when the user's
- * project has no local install (npx / global). Source runs (tsx from the
- * monorepo) skip both — the host loader and tsconfig paths already cover
- * them.
+ * project has no local install (npx / global). The same hooks retry bare
+ * npm specifiers from monorepo `packages/agent-serve/` source against this
+ * package (hosted factory engines install only the agent directory).
+ * Source runs (tsx from the monorepo) skip both — the host loader and
+ * tsconfig paths already cover them.
  */
 import { stat } from "node:fs/promises";
@@ -175,7 +177,16 @@ function registerFrameworkAliases(): void {
     fallbackAliases[`${AGENTKIT_PACKAGE_NAME}${suffix}`] = target;
   }
   const hooksUrl = new URL("./authored-alias-hooks.js", import.meta.url);
-  const data: AuthoredAliasHookData = { directAliases, fallbackAliases };
+  const data: AuthoredAliasHookData = {
+    directAliases,
+    fallbackAliases,
+    // Hosted factory agents relative-import this package's src/ from a
+    // monorepo checkout while npm install ran only in the agent directory.
+    // Bare specifiers from that tree retry against this package.json.
+    sourceTreeFallbackParentURL: pathToFileURL(
+      join(packageRootDir(), "package.json")
+    ).href,
+  };
   // `node:module`'s register() is synchronous: it blocks until the hooks
   // thread has initialized, so the aliases are active when it returns.
   registerModuleHooks(hooksUrl, { data });

package/src/internal/deployment-scm-event-stream.ts CHANGED Viewed

@@ -34,10 +34,10 @@
  * only.
  */
-// Node builtins only: hosted engines install the consuming agent's directory
-// alone and load this file as raw TypeScript source, so third-party imports
-// (even zod) do not resolve from here. See the tenant-mcp internals for the
-// same constraint.
+// Hosted engines install the consuming agent's directory alone and load this
+// file as raw TypeScript source. Relative and `node:` imports resolve here;
+// this package's own npm dependencies retry against the running `@cursor/july`
+// install (authored-alias-hooks). Do not add deps that package does not have.
 import { createHmac } from "node:crypto";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";

package/src/internal/review-comments.ts CHANGED Viewed

@@ -110,6 +110,43 @@ export type ReviewCommentReaderImplementation = {
   ) => Promise<ExistingReviewComment[]>;
 };
+export type ResolveReviewThreadsArgs = {
+  target: ScmReviewTarget;
+  /** REST comment ids whose threads should be resolved. */
+  commentIds: readonly number[];
+  signal?: AbortSignal;
+};
+/**
+ * Outcome of resolving review threads for a set of comment ids. Callers
+ * treat this as best-effort actuation: a failed resolve must not fail the
+ * review that already posted.
+ */
+export type ResolveReviewThreadsResult = {
+  requested: number;
+  resolved: number;
+  alreadyResolved: number;
+  notFound: number;
+  failed: number;
+  detail: string;
+};
+/**
+ * Write side of thread resolution, the counterpart of
+ * {@link ReviewCommentReaderImplementation}. Bugbot's equivalent is
+ * `IGitProvider.resolveReviewThreadForComment` / `resolveThreads`.
+ *
+ * GitHub only exposes resolve via GraphQL (`resolveReviewThread`). REST
+ * has no equivalent. The mutation runs as whatever identity minted the
+ * bound GitHub client — for `githubChannel({ cursorAccount })` that is
+ * the Cursor installation, the same identity that posted the comments.
+ */
+export type ReviewThreadResolverImplementation = {
+  resolveReviewThreadsForComments: (
+    args: ResolveReviewThreadsArgs
+  ) => Promise<ResolveReviewThreadsResult>;
+};
 /** Parse a PR URL into the SCM target to read comments from. */
 export function resolveScmReviewTarget(
   prUrl: string
@@ -141,9 +178,65 @@ export function createReviewCommentReader(args: {
   }
 }
+/**
+ * Resolver for a resolved target. Returns undefined when the host cannot
+ * serve that provider, so callers degrade instead of throwing.
+ */
+export function createReviewThreadResolver(args: {
+  target: ScmReviewTarget;
+  github?: HostGitHubClient;
+}): ReviewThreadResolverImplementation | undefined {
+  switch (args.target.provider) {
+    case "github":
+      return args.github === undefined
+        ? undefined
+        : createHostGithubReviewThreadResolver(args.github);
+  }
+}
+/**
+ * Resolve the review threads that own `commentIds` on `prUrl`.
+ *
+ * No-ops (never throws) when the PR is on an SCM this host cannot write,
+ * no client is bound, or `commentIds` is empty. Same degrade-don't-fail
+ * posture as {@link createReviewCommentReader}.
+ */
+export async function resolveReviewThreadsForComments(args: {
+  prUrl: string;
+  commentIds: readonly number[];
+  github?: HostGitHubClient;
+  resolver?: ReviewThreadResolverImplementation;
+  signal?: AbortSignal;
+}): Promise<ResolveReviewThreadsResult> {
+  if (args.commentIds.length === 0) {
+    return skippedResolve("no comments to resolve");
+  }
+  const target = resolveScmReviewTarget(args.prUrl);
+  if (target === undefined) {
+    return skippedResolve("no SCM resolver for this PR URL");
+  }
+  const resolver =
+    args.resolver ??
+    createReviewThreadResolver({
+      target,
+      github: args.github,
+    });
+  if (resolver === undefined) {
+    return skippedResolve("no GitHub client bound to resolve threads");
+  }
+  return resolver.resolveReviewThreadsForComments({
+    target,
+    commentIds: args.commentIds,
+    signal: args.signal,
+  });
+}
 /** Cap on pages pulled per PR; GitHub serves 100 comments per page. */
 const REVIEW_COMMENTS_MAX_PAGES = 5;
 const REVIEW_COMMENTS_PAGE_SIZE = 100;
+/** Cap on review-thread pages when mapping comment ids to GraphQL thread ids. */
+const REVIEW_THREADS_MAX_PAGES = 20;
+const REVIEW_THREADS_PAGE_SIZE = 100;
 /**
  * Reads inline review comments through the host GitHub client (Cursor
@@ -182,6 +275,188 @@ export function createHostGithubReviewCommentReader(
   };
 }
+type GithubReviewThreadNode = {
+  id?: string;
+  isResolved?: boolean;
+  comments?: {
+    nodes?: Array<{ databaseId?: number | null } | null>;
+  };
+};
+type GithubReviewThreadsQuery = {
+  repository?: {
+    pullRequest?: {
+      reviewThreads?: {
+        nodes?: Array<GithubReviewThreadNode | null>;
+        pageInfo?: { hasNextPage?: boolean; endCursor?: string | null };
+      };
+    } | null;
+  } | null;
+};
+type GithubResolveThreadMutation = {
+  resolveReviewThread?: {
+    thread?: { isResolved?: boolean };
+  };
+};
+/**
+ * Resolves inline review threads through the host GitHub client (Cursor
+ * account lease, App installation token, or PAT). GitHub GraphQL has no
+ * comment→thread field, so this pages the PR's review threads and matches
+ * each REST comment id by `databaseId` — the same approach as Bugbot's
+ * `resolveReviewThreadForComment`.
+ */
+export function createHostGithubReviewThreadResolver(
+  github: HostGitHubClient
+): ReviewThreadResolverImplementation {
+  return {
+    async resolveReviewThreadsForComments({ target, commentIds, signal }) {
+      const uniqueIds = [...new Set(commentIds.filter((id) => id > 0))];
+      if (uniqueIds.length === 0) {
+        return skippedResolve("no comments to resolve");
+      }
+      const [owner, repo] = target.repo.split("/", 2);
+      if (owner === undefined || repo === undefined || repo === "") {
+        return skippedResolve("unparseable owner/repo from PR URL");
+      }
+      try {
+        const octokit = await github.getOctokit();
+        const wanted = new Set(uniqueIds);
+        const matched = new Map<
+          number,
+          { threadId: string; isResolved: boolean }
+        >();
+        let cursor: string | null = null;
+        for (let page = 0; page < REVIEW_THREADS_MAX_PAGES; page++) {
+          signal?.throwIfAborted();
+          const response = (await octokit.graphql(REVIEW_THREADS_FOR_PR_QUERY, {
+            owner,
+            repo,
+            number: target.prNumber,
+            cursor,
+          })) as GithubReviewThreadsQuery;
+          const reviewThreads = response.repository?.pullRequest?.reviewThreads;
+          for (const thread of reviewThreads?.nodes ?? []) {
+            if (thread?.id === undefined || thread.id === "") {
+              continue;
+            }
+            for (const comment of thread.comments?.nodes ?? []) {
+              const databaseId = comment?.databaseId;
+              if (
+                databaseId !== undefined &&
+                databaseId !== null &&
+                wanted.has(databaseId) &&
+                !matched.has(databaseId)
+              ) {
+                matched.set(databaseId, {
+                  threadId: thread.id,
+                  isResolved: thread.isResolved === true,
+                });
+              }
+            }
+          }
+          if (matched.size === wanted.size) {
+            break;
+          }
+          const pageInfo = reviewThreads?.pageInfo;
+          if (pageInfo?.hasNextPage !== true || !pageInfo.endCursor) {
+            break;
+          }
+          cursor = pageInfo.endCursor;
+        }
+        const toResolve = [
+          ...new Map(
+            [...matched.values()]
+              .filter((thread) => !thread.isResolved)
+              .map((thread) => [thread.threadId, thread.threadId])
+          ).values(),
+        ];
+        let resolved = 0;
+        let failed = 0;
+        for (const threadId of toResolve) {
+          signal?.throwIfAborted();
+          try {
+            const mutation = (await octokit.graphql(
+              RESOLVE_REVIEW_THREAD_MUTATION,
+              { threadId }
+            )) as GithubResolveThreadMutation;
+            if (mutation.resolveReviewThread?.thread?.isResolved === true) {
+              resolved += 1;
+            } else {
+              failed += 1;
+            }
+          } catch {
+            failed += 1;
+          }
+        }
+        const alreadyResolved = new Set(
+          [...matched.values()]
+            .filter((thread) => thread.isResolved)
+            .map((thread) => thread.threadId)
+        ).size;
+        const notFound = wanted.size - matched.size;
+        return {
+          requested: uniqueIds.length,
+          resolved,
+          alreadyResolved,
+          notFound,
+          failed,
+          detail: `resolved ${resolved} of ${toResolve.length} open thread(s) for ${uniqueIds.length} comment(s) via host GitHub (${alreadyResolved} already resolved, ${notFound} not found, ${failed} failed)`,
+        };
+      } catch (error) {
+        if (signal?.aborted) {
+          throw error;
+        }
+        return {
+          requested: uniqueIds.length,
+          resolved: 0,
+          alreadyResolved: 0,
+          notFound: 0,
+          failed: uniqueIds.length,
+          detail: `host GitHub thread resolve failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+      }
+    },
+  };
+}
+const REVIEW_THREADS_FOR_PR_QUERY = `
+query ReviewThreadsForPr(
+  $owner: String!
+  $repo: String!
+  $number: Int!
+  $cursor: String
+) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $number) {
+      reviewThreads(first: ${REVIEW_THREADS_PAGE_SIZE}, after: $cursor) {
+        nodes {
+          id
+          isResolved
+          comments(first: ${REVIEW_THREADS_PAGE_SIZE}) {
+            nodes { databaseId }
+          }
+        }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  }
+}
+`;
+const RESOLVE_REVIEW_THREAD_MUTATION = `
+mutation ResolveReviewThread($threadId: ID!) {
+  resolveReviewThread(input: { threadId: $threadId }) {
+    thread { isResolved }
+  }
+}
+`;
 type GithubReviewCommentLike = {
   id: number;
   path: string;
@@ -504,6 +779,17 @@ function skippedHost(detail: string): ReviewCommentPostResult {
   };
 }
+function skippedResolve(detail: string): ResolveReviewThreadsResult {
+  return {
+    requested: 0,
+    resolved: 0,
+    alreadyResolved: 0,
+    notFound: 0,
+    failed: 0,
+    detail,
+  };
+}
 function parseGithubPrUrl(
   prUrl: string
 ):