@mndrk/agx 2.0.44 → 2.0.45

package/cloud-runtime/standalone/hooks/useLinearIssues.ts

@@ -14,10 +14,16 @@ interface Filters {
   teamId?: string;
   status?: string;
   search?: string;
+  assigneeId?: string;
   assignedToMe?: boolean;
   cycleId?: string;
 }
 
+interface UseLinearIssuesOptions {
+  projectSlug?: string;
+  limit?: number;
+}
+
 interface UseLinearIssuesReturn {
   issues: LinearIssue[];
   loading: boolean;
@@ -26,16 +32,25 @@ interface UseLinearIssuesReturn {
   refresh: () => Promise<void>;
 }
 
-export function useLinearIssues(filters: Filters, enabled = true): UseLinearIssuesReturn {
+export function useLinearIssues(
+  filters: Filters,
+  enabled = true,
+  options: UseLinearIssuesOptions = {}
+): UseLinearIssuesReturn {
   const [issues, setIssues] = useState<LinearIssue[]>([]);
   const [loading, setLoading] = useState(true);
   const [cursor, setCursor] = useState<string | null>(null);
   const [hasMore, setHasMore] = useState(false);
   const cursorRef = useRef(cursor);
+  const hydratedRef = useRef(false);
   cursorRef.current = cursor;
 
+  useEffect(() => {
+    hydratedRef.current = false;
+  }, [options.projectSlug]);
+
   const fetchPage = useCallback(
-    async (append: boolean) => {
+    async (append: boolean, refresh = false) => {
       if (!enabled) return;
       setLoading(true);
       try {
@@ -43,9 +58,13 @@ export function useLinearIssues(filters: Filters, enabled = true): UseLinearIssu
         if (filters.teamId) params.set("teamId", filters.teamId);
         if (filters.status) params.set("status", filters.status);
         if (filters.search) params.set("search", filters.search);
-        if (filters.assignedToMe) params.set("assignedToMe", "true");
+        if (filters.assigneeId) params.set("assigneeId", filters.assigneeId);
+        else if (filters.assignedToMe) params.set("assignedToMe", "true");
         if (filters.cycleId) params.set("cycleId", filters.cycleId);
         if (append && cursorRef.current) params.set("cursor", cursorRef.current);
+        if (options.projectSlug) params.set("projectSlug", options.projectSlug);
+        if (options.limit) params.set("limit", String(options.limit));
+        if (refresh) params.set("refresh", "true");
 
         const res = await fetch(`/api/linear/issues?${params.toString()}`);
         const data = await res.json();
@@ -54,24 +73,25 @@ export function useLinearIssues(filters: Filters, enabled = true): UseLinearIssu
         setIssues((prev) => (append ? [...prev, ...newIssues] : newIssues));
         setCursor(data.pageInfo?.endCursor ?? null);
         setHasMore(data.pageInfo?.hasNextPage ?? false);
+        hydratedRef.current = true;
       } catch {
         if (!append) setIssues([]);
       } finally {
         setLoading(false);
       }
     },
-    [filters.teamId, filters.status, filters.search, filters.assignedToMe, filters.cycleId, enabled],
+    [filters.teamId, filters.status, filters.search, filters.assigneeId, filters.assignedToMe, filters.cycleId, enabled, options.projectSlug, options.limit],
   );
 
   useEffect(() => {
     setCursor(null);
-    fetchPage(false);
+    void fetchPage(false, !hydratedRef.current);
   }, [fetchPage]);
 
   const loadMore = useCallback(() => fetchPage(true), [fetchPage]);
   const refresh = useCallback(() => {
     setCursor(null);
-    return fetchPage(false);
+    return fetchPage(false, true);
   }, [fetchPage]);
 
   return { issues, loading, hasMore, loadMore, refresh };

package/cloud-runtime/standalone/hooks/useMentionAutocomplete.ts

@@ -25,10 +25,21 @@ export interface MentionProject {
   slug: string;
 }
 
+export interface MentionLinearIssue {
+  id: string;
+  identifier: string;
+  title: string;
+  status: string;
+  url: string | null;
+  assignee: string | null;
+  updatedAt: string;
+}
+
 export type MentionItem =
   | { kind: "agent"; participant: Participant; group: string }
   | { kind: "project-group"; project: ProjectWithAgents; group: string }
-  | { kind: "project"; project: MentionProject; group: string };
+  | { kind: "project"; project: MentionProject; group: string }
+  | { kind: "ticket"; issue: MentionLinearIssue; group: string };
 
 export type MentionSuggestion = MentionItem;
 
@@ -39,6 +50,8 @@ export interface UseMentionAutocompleteOptions {
   projectGroups?: ProjectWithAgents[];
   /** Mentionable projects */
   projects?: MentionProject[];
+  /** Cached Linear tickets available for @ mentions */
+  linearIssues?: MentionLinearIssue[];
   /** Maximum number of suggestions to show */
   maxSuggestions?: number;
 }
@@ -151,7 +164,8 @@ export function filterSuggestions(
   query: string,
   maxSuggestions: number,
   projectGroups: ProjectWithAgents[] = [],
-  projects: MentionProject[] = []
+  projects: MentionProject[] = [],
+  linearIssues: MentionLinearIssue[] = []
 ): MentionSuggestion[] {
   const lowerQuery = query.toLowerCase();
   const participantById = new Map(participants.map((p) => [p.id, p]));
@@ -216,7 +230,26 @@ export function filterSuggestions(
     }
   }
 
-  // 4. Ungrouped agents (not in any project)
+  // 4. Linear tickets (only once the user has started typing)
+  if (lowerQuery) {
+    linearIssues
+      .map((issue) => ({
+        issue,
+        score: scoreIssueMatch(issue, lowerQuery),
+      }))
+      .filter((entry): entry is { issue: MentionLinearIssue; score: number } => entry.score !== null)
+      .sort((left, right) => {
+        if (right.score !== left.score) {
+          return right.score - left.score;
+        }
+        return left.issue.identifier.localeCompare(right.issue.identifier);
+      })
+      .forEach(({ issue }) => {
+        result.push({ kind: "ticket", issue, group: "Tickets" });
+      });
+  }
+
+  // 5. Ungrouped agents (not in any project)
   const ungrouped: { participant: Participant; score: number }[] = [];
   for (const p of participants) {
     if (projectAgentIds.has(p.id)) continue;
@@ -236,6 +269,7 @@ export function useMentionAutocomplete({
   participants,
   projectGroups = [],
   projects = [],
+  linearIssues = [],
   maxSuggestions = 6,
 }: UseMentionAutocompleteOptions): UseMentionAutocompleteReturn {
   const [token, setToken] = useState<MentionToken | null>(null);
@@ -246,8 +280,8 @@ export function useMentionAutocomplete({
   const query = token?.query ?? "";
 
   const filteredSuggestions = useMemo(() => {
-    return filterSuggestions(participants, query, maxSuggestions, projectGroups, projects);
-  }, [participants, query, maxSuggestions, projectGroups, projects]);
+    return filterSuggestions(participants, query, maxSuggestions, projectGroups, projects, linearIssues);
+  }, [participants, query, maxSuggestions, projectGroups, projects, linearIssues]);
 
   const updateTokenFromInput = useCallback((text: string, cursorPos: number) => {
     const newToken = detectMentionToken(text, cursorPos);
@@ -320,7 +354,9 @@ export function useMentionAutocomplete({
           ? suggestion.project.name
           : suggestion.kind === "project"
             ? suggestion.project.name
-            : suggestion.participant.name;
+            : suggestion.kind === "ticket"
+              ? suggestion.issue.identifier
+              : suggestion.participant.name;
       const atPrefix = token.isParallel ? "@@" : "@";
       const replacement = `${atPrefix}${name} `;
 
@@ -362,3 +398,15 @@ export function useMentionAutocomplete({
     endComposition,
   };
 }
+
+function scoreIssueMatch(issue: MentionLinearIssue, lowerQuery: string): number | null {
+  const identifier = issue.identifier.toLowerCase();
+  const title = issue.title.toLowerCase();
+
+  if (identifier === lowerQuery) return 5;
+  if (identifier.startsWith(lowerQuery)) return 4;
+  if (title.startsWith(lowerQuery)) return 3;
+  if (identifier.includes(lowerQuery)) return 2;
+  if (title.includes(lowerQuery)) return 1;
+  return null;
+}

package/cloud-runtime/standalone/instrumentation.ts

@@ -3,6 +3,7 @@ const PROMPT_JOB_POLL_INTERVAL_MS = 15_000;
 
 export async function register() {
   if (process.env.NEXT_RUNTIME === 'nodejs') {
+    const { getConfiguredLocalServerPort } = await import("./lib/app-config");
     await import("./lib/check-node-version");
     const { getQueue, QUEUE_NAMES } = await import('@/lib/queue/boss');
     const { taskProcessor } = await import('@/lib/orchestrator/processor');
@@ -22,7 +23,7 @@ export async function register() {
     const { GraphStore } = await import('@/src/graph/store');
 
     // Prompt job poller — drives recurring prompt-based scheduled tasks
-    const port = process.env.PORT || '3000';
+    const port = getConfiguredLocalServerPort();
     const baseUrl = `http://localhost:${port}`;
     let promptJobPollReady = false;
 

package/cloud-runtime/standalone/lib/app-config.ts

@@ -0,0 +1,55 @@
+const DEFAULT_LOCAL_APP_PORT = 41741;
+
+function normalizeBaseUrl(value: string | null | undefined): string | null {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  return trimmed.replace(/\/+$/, "");
+}
+
+export const LOCAL_APP_PORT = DEFAULT_LOCAL_APP_PORT;
+export const LOCAL_APP_URL = `http://localhost:${LOCAL_APP_PORT}`;
+
+export function getConfiguredAppBaseUrl(): string {
+  return (
+    normalizeBaseUrl(process.env.NEXT_PUBLIC_APP_URL) ??
+    normalizeBaseUrl(process.env.AGX_BOARD_URL) ??
+    normalizeBaseUrl(process.env.NEXT_PUBLIC_AGX_BOARD_URL) ??
+    LOCAL_APP_URL
+  );
+}
+
+export function getConfiguredBoardBaseUrl(): string {
+  return (
+    normalizeBaseUrl(process.env.AGX_BOARD_URL) ??
+    normalizeBaseUrl(process.env.NEXT_PUBLIC_AGX_BOARD_URL) ??
+    normalizeBaseUrl(process.env.NEXT_PUBLIC_APP_URL) ??
+    LOCAL_APP_URL
+  );
+}
+
+export function getConfiguredLocalServerPort(): string {
+  return process.env.PORT?.trim() || String(LOCAL_APP_PORT);
+}
+
+export function getAllowedOrigins(): string[] {
+  const origins = new Set<string>([
+    LOCAL_APP_URL,
+    `http://127.0.0.1:${LOCAL_APP_PORT}`,
+  ]);
+
+  for (const value of [
+    process.env.NEXT_PUBLIC_APP_URL,
+    process.env.AGX_BOARD_URL,
+    process.env.NEXT_PUBLIC_AGX_BOARD_URL,
+  ]) {
+    const normalized = normalizeBaseUrl(value);
+    if (normalized) {
+      origins.add(normalized);
+    }
+  }
+
+  return Array.from(origins);
+}

package/cloud-runtime/standalone/lib/chat/linear-issue-context.ts

@@ -0,0 +1,79 @@
+import type { JSONContent } from "@tiptap/core";
+
+export interface MentionedLinearIssueContext {
+  id: string;
+  identifier: string;
+  title: string;
+  url: string | null;
+  status: string;
+  assignee: string | null;
+  assigneeId: string | null;
+  assigneeEmail: string | null;
+  isAssignedToMe: boolean;
+  teamId: string | null;
+  teamName: string | null;
+  teamKey: string | null;
+  cycleId: string | null;
+  cycleName: string | null;
+  cycleNumber: number | null;
+  description: string | null;
+  updatedAt: string;
+  pulledAt: string;
+}
+
+function walkNodes(
+  nodes: JSONContent[] | undefined,
+  visitor: (node: JSONContent) => void
+): void {
+  if (!nodes) return;
+  for (const node of nodes) {
+    visitor(node);
+    walkNodes(node.content, visitor);
+  }
+}
+
+function escapeAttribute(value: string): string {
+  return value
+    .replace(/&/g, "&")
+    .replace(/"/g, """)
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
+export function extractMentionedLinearIssueIds(doc: JSONContent): string[] {
+  const issueIds = new Set<string>();
+
+  walkNodes(doc.content, (node) => {
+    if (node.type !== "linearIssueMention") return;
+    const id = typeof node.attrs?.id === "string" ? node.attrs.id.trim() : "";
+    if (id) {
+      issueIds.add(id);
+    }
+  });
+
+  return Array.from(issueIds);
+}
+
+export function buildLinearIssueContextPrefix(issues: MentionedLinearIssueContext[]): string {
+  if (issues.length === 0) return "";
+
+  const blocks = issues.map((issue) => {
+    const parts = [
+      `<linear-issue identifier="${escapeAttribute(issue.identifier)}" status="${escapeAttribute(issue.status)}"${issue.assignee ? ` assignee="${escapeAttribute(issue.assignee)}"` : ""}>`,
+      `Title: ${issue.title}`,
+      issue.url ? `URL: ${issue.url}` : null,
+      issue.teamName ? `Team: ${issue.teamName}` : null,
+      issue.cycleName || issue.cycleNumber != null
+        ? `Cycle: ${issue.cycleName ?? `Cycle ${issue.cycleNumber}`}`
+        : null,
+      `Updated: ${issue.updatedAt}`,
+      "",
+      issue.description?.trim() || "No description provided.",
+      "</linear-issue>",
+    ];
+
+    return parts.filter((part): part is string => part !== null).join("\n");
+  });
+
+  return `Referenced Linear tickets (only because the user explicitly @mentioned them):\n\n${blocks.join("\n\n")}\n\n`;
+}

package/cloud-runtime/standalone/lib/linear-client.ts

@@ -21,26 +21,64 @@ interface LinearGraphQLResponse<TData> {
 }
 
 interface LinearViewer {
+  id: string;
   name: string;
   email: string;
 }
 
+export interface LinearUser {
+  id: string;
+  name: string;
+}
+
+interface RawLinearUserNode {
+  id: string;
+  name: string;
+}
+
+export interface LinearTeam {
+  id: string;
+  name: string;
+}
+
+interface RawLinearTeamNode {
+  id: string;
+  name: string;
+}
+
 interface LinearIssueState {
   name: string;
 }
 
 interface LinearIssueAssignee {
+  id: string;
+  name: string;
+  email: string | null;
+}
+
+interface LinearIssueTeam {
+  id: string;
   name: string;
+  key: string;
+}
+
+interface LinearIssueCycle {
+  id: string;
+  number: number;
+  name: string | null;
 }
 
 interface RawLinearIssueNode {
   id: string;
   identifier: string;
   title: string;
+  description: string | null;
   url: string | null;
   updatedAt: string;
   state: LinearIssueState | null;
   assignee: LinearIssueAssignee | null;
+  team: LinearIssueTeam | null;
+  cycle: LinearIssueCycle | null;
 }
 
 type LinearIssueFilter = Record<string, unknown>;
@@ -49,10 +87,13 @@ export interface LinearIssueNode {
   id: string;
   identifier: string;
   title: string;
+  description: string | null;
   url: string | null;
   updatedAt: string;
   state: Promise<LinearIssueState | null>;
   assignee: Promise<LinearIssueAssignee | null>;
+  team: Promise<LinearIssueTeam | null>;
+  cycle: Promise<LinearIssueCycle | null>;
 }
 
 export interface LinearCycle {
@@ -61,6 +102,8 @@ export interface LinearCycle {
   name: string | null;
   startsAt: string;
   endsAt: string;
+  teamId: string | null;
+  teamName: string | null;
 }
 
 interface RawLinearCycleNode {
@@ -69,6 +112,10 @@ interface RawLinearCycleNode {
   name: string | null;
   startsAt: string;
   endsAt: string;
+  team: {
+    id: string;
+    name: string;
+  } | null;
 }
 
 interface LinearIssueConnection {
@@ -159,10 +206,60 @@ export class LinearClient {
 
   get viewer(): Promise<LinearViewer> {
     return this.request<{ viewer: LinearViewer }>(
-      `query { viewer { name email } }`,
+      `query { viewer { id name email } }`,
     ).then((data) => data.viewer);
   }
 
+  async users(): Promise<LinearUser[]> {
+    const data = await this.request<{
+      users: {
+        nodes: RawLinearUserNode[];
+      };
+    }>(
+      `query {
+        users(first: 100) {
+          nodes {
+            id
+            name
+          }
+        }
+      }`,
+    );
+
+    return data.users.nodes
+      .filter((user) => user.name.trim().length > 0)
+      .map((user) => ({
+        id: user.id,
+        name: user.name,
+      }))
+      .sort((left, right) => left.name.localeCompare(right.name));
+  }
+
+  async teams(): Promise<LinearTeam[]> {
+    const data = await this.request<{
+      teams: {
+        nodes: RawLinearTeamNode[];
+      };
+    }>(
+      `query {
+        teams(first: 50) {
+          nodes {
+            id
+            name
+          }
+        }
+      }`,
+    );
+
+    return data.teams.nodes
+      .filter((team) => team.name.trim().length > 0)
+      .map((team) => ({
+        id: team.id,
+        name: team.name,
+      }))
+      .sort((left, right) => left.name.localeCompare(right.name));
+  }
+
   async issues(params: {
     first: number;
     after?: string;
@@ -185,10 +282,13 @@ export class LinearClient {
             id
             identifier
             title
+            description
             url
             updatedAt
             state { name }
-            assignee { name }
+            assignee { id name email }
+            team { id name key }
+            cycle { id number name }
           }
           pageInfo {
             hasNextPage
@@ -203,10 +303,13 @@ export class LinearClient {
         id: issue.id,
         identifier: issue.identifier,
         title: issue.title,
+        description: issue.description,
         url: issue.url,
         updatedAt: issue.updatedAt,
         state: Promise.resolve(issue.state),
         assignee: Promise.resolve(issue.assignee),
+        team: Promise.resolve(issue.team),
+        cycle: Promise.resolve(issue.cycle),
       })),
       pageInfo: data.issues.pageInfo,
     };
@@ -214,30 +317,78 @@ export class LinearClient {
 
   async cycles(): Promise<LinearCycle[]> {
     const data = await this.request<{
-      cycles: {
-        nodes: RawLinearCycleNode[];
+      teams: {
+        nodes: Array<{
+          id: string;
+          name: string;
+          activeCycle: RawLinearCycleNode | null;
+          cycles: {
+            nodes: RawLinearCycleNode[];
+          };
+        }>;
       };
     }>(
       `query {
-        cycles(orderBy: startsAt, first: 20) {
+        teams(first: 50) {
           nodes {
             id
-            number
             name
-            startsAt
-            endsAt
+            activeCycle {
+              id
+              number
+              name
+              startsAt
+              endsAt
+              team {
+                id
+                name
+              }
+            }
+            cycles(first: 20) {
+              nodes {
+                id
+                number
+                name
+                startsAt
+                endsAt
+                team {
+                  id
+                  name
+                }
+              }
+            }
           }
         }
       }`,
     );
 
-    return data.cycles.nodes.map((cycle) => ({
-      id: cycle.id,
-      number: cycle.number,
-      name: cycle.name,
-      startsAt: cycle.startsAt,
-      endsAt: cycle.endsAt,
-    }));
+    const deduped = new Map<string, LinearCycle>();
+    for (const team of data.teams.nodes) {
+      const cycleNodes = [
+        ...(team.activeCycle ? [team.activeCycle] : []),
+        ...team.cycles.nodes,
+      ];
+
+      for (const cycle of cycleNodes) {
+        if (deduped.has(cycle.id)) {
+          continue;
+        }
+
+        deduped.set(cycle.id, {
+          id: cycle.id,
+          number: cycle.number,
+          name: cycle.name,
+          startsAt: cycle.startsAt,
+          endsAt: cycle.endsAt,
+          teamId: cycle.team?.id ?? team.id,
+          teamName: cycle.team?.name ?? team.name,
+        });
+      }
+    }
+
+    return [...deduped.values()].sort(
+      (left, right) => new Date(right.startsAt).getTime() - new Date(left.startsAt).getTime()
+    );
   }
 
   private async request<TData>(query: string): Promise<TData> {