@mndrk/agx 2.0.44 → 2.0.46

package/cloud-runtime/standalone/components/chat-ui/Composer.tsx

@@ -6,6 +6,7 @@ import StarterKit from "@tiptap/starter-kit";
 import Placeholder from "@tiptap/extension-placeholder";
 import {
   useMentionAutocomplete,
+  type MentionLinearIssue,
   type MentionProject,
   type MentionSuggestion,
 } from "@/hooks/useMentionAutocomplete";
@@ -15,7 +16,12 @@ import { useFileMention } from "@/hooks/useFileMention";
 import { useThreadMention, type Discussion } from "@/hooks/useThreadMention";
 import { useComposerAttachments } from "@/hooks/useComposerAttachments";
 import { useComposerHistory } from "@/hooks/useComposerHistory";
+import { useLinearIssueMentions } from "@/hooks/useLinearIssueMentions";
 import { buildAgentContext } from "@/lib/chat/agentContextBuilder";
+import {
+  buildLinearIssueContextPrefix,
+  extractMentionedLinearIssueIds,
+} from "@/lib/chat/linear-issue-context";
 import {
   extractComposerRouting,
   type ComposerRoutingMetadata,
@@ -31,6 +37,7 @@ import {
   ProjectMention,
   FileMention,
   ThreadMention,
+  LinearIssueMention,
 } from "@/lib/tiptap/composer-mentions";
 import { serializeToPlainText } from "@/lib/tiptap/serialize-composer";
 import { getCurrentParagraphText, plainTextRangeToPos } from "@/lib/tiptap/editor-utils";
@@ -76,6 +83,8 @@ interface Props {
   projects?: MentionProject[];
   /** Projects with agent rosters */
   projectGroups?: ProjectWithAgents[];
+  /** Active project slug, used for scoping cached Linear issue pulls */
+  projectSlug?: string;
   /** All messages in the current thread — used for @# discussion mentions */
   messages?: GroupMessage[];
   commands: SlashCommand[];
@@ -129,6 +138,7 @@ export function Composer({
   participants,
   projects = [],
   projectGroups = [],
+  projectSlug,
   messages: allMessages = [],
   commands,
   placeholder = "Message — @name to mention, /search, /summarize",
@@ -173,8 +183,16 @@ export function Composer({
   }, []);
 
   const [threadRefs, setThreadRefs] = useState<ThreadRef[]>([]);
-
-  const mention = useMentionAutocomplete({ participants, projectGroups, projects, maxSuggestions: 8 });
+  const { issues: cachedLinearIssues } = useLinearIssueMentions({ projectSlug });
+  const linearIssues = cachedLinearIssues as MentionLinearIssue[];
+
+  const mention = useMentionAutocomplete({
+    participants,
+    projectGroups,
+    projects,
+    linearIssues,
+    maxSuggestions: 8,
+  });
   const command = useCommandAutocomplete({ commands, maxSuggestions: 6 });
   const fileMention = useFileMention({ maxSuggestions: 8 });
   const threadMention = useThreadMention({ messages: allMessages, maxSuggestions: 8 });
@@ -235,6 +253,7 @@ export function Composer({
       ProjectMention,
       FileMention,
       ThreadMention,
+      LinearIssueMention,
     ],
     editorProps: {
       attributes: {
@@ -473,6 +492,17 @@ export function Composer({
                 name: suggestion.project.name,
               },
             }
+          : suggestion.kind === "ticket"
+            ? {
+                type: "linearIssueMention",
+                attrs: {
+                  id: suggestion.issue.id,
+                  identifier: suggestion.issue.identifier,
+                  title: suggestion.issue.title,
+                  status: suggestion.issue.status,
+                  url: suggestion.issue.url,
+                },
+              }
           : {
               type: "participantMention",
               attrs: {
@@ -628,6 +658,28 @@ export function Composer({
       }
     }
 
+    const mentionedLinearIssueIds = extractMentionedLinearIssueIds(doc);
+    if (mentionedLinearIssueIds.length > 0) {
+      try {
+        const response = await fetch("/api/linear/issues/context", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ issueIds: mentionedLinearIssueIds }),
+        });
+        if (!response.ok) {
+          throw new Error(`Failed to load issue context: ${response.status}`);
+        }
+        const data = await response.json().catch(() => ({}));
+        const issues = Array.isArray(data.issues) ? data.issues : [];
+        const issueContext = buildLinearIssueContextPrefix(issues);
+        if (issueContext) {
+          prefixParts.push(issueContext.trimEnd());
+        }
+      } catch (error) {
+        console.error("Failed to load Linear issue mention context:", error);
+      }
+    }
+
     const promptPrefix = prefixParts.length > 0 ? prefixParts.join("\n\n") + "\n\n" : undefined;
     const routing = extractComposerRouting(doc, pinnedParticipantId);
 

package/cloud-runtime/standalone/components/chat-ui/MentionPopover.tsx

@@ -2,7 +2,7 @@
 
 import { useEffect, useRef } from "react";
 import type { MentionSuggestion } from "@/hooks/useMentionAutocomplete";
-import { FolderKanban, Users } from "lucide-react";
+import { FolderKanban, Tag, Users } from "lucide-react";
 
 interface MentionPopoverProps {
   isOpen: boolean;
@@ -55,7 +55,9 @@ export function MentionPopover({
               ? `project-group-${suggestion.project.id}`
               : suggestion.kind === "project"
                 ? `project-${suggestion.project.id}`
-                : suggestion.participant.id;
+                : suggestion.kind === "ticket"
+                  ? `ticket-${suggestion.issue.id}`
+                  : suggestion.participant.id;
           const group = suggestion.group;
 
           // Show group header if this is a new non-empty group
@@ -131,6 +133,45 @@ export function MentionPopover({
             );
           }
 
+          if (suggestion.kind === "ticket") {
+            return (
+              <div key={id}>
+                {groupHeader}
+                <button
+                  type="button"
+                  role="option"
+                  id={`${optionIdPrefix}-${id}`}
+                  aria-selected={isActive}
+                  ref={(element) => {
+                    optionRefs.current[index] = element;
+                  }}
+                  className={`w-full px-3 py-2 text-left text-sm transition-colors ${
+                    isActive ? "bg-[var(--primary-muted)] text-[var(--foreground)]" : "text-[var(--foreground)] hover:bg-[var(--app-shell-subtle)]"
+                  }`}
+                  onMouseDown={(e) => {
+                    e.preventDefault();
+                  }}
+                  onClick={() => onSelect(suggestion)}
+                >
+                  <span className="flex items-start gap-2">
+                    <Tag className="mt-0.5 h-3.5 w-3.5 text-[var(--muted-foreground)]" aria-hidden />
+                    <span className="min-w-0">
+                      <span className="block font-medium">
+                        {suggestion.issue.identifier}
+                        <span className="ml-2 text-xs text-[var(--muted-foreground)]">
+                          {suggestion.issue.status}
+                        </span>
+                      </span>
+                      <span className="block truncate text-xs text-[var(--muted-foreground)]">
+                        {suggestion.issue.title}
+                      </span>
+                    </span>
+                  </span>
+                </button>
+              </div>
+            );
+          }
+
           const participant = suggestion.participant;
           return (
             <div key={id}>

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

@@ -0,0 +1,64 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import type { LinearIssue } from "@/hooks/useLinearIssues";
+
+interface UseLinearIssueMentionsOptions {
+  projectSlug?: string;
+  enabled?: boolean;
+  limit?: number;
+}
+
+interface UseLinearIssueMentionsReturn {
+  issues: LinearIssue[];
+  loading: boolean;
+}
+
+export function useLinearIssueMentions({
+  projectSlug,
+  enabled = true,
+  limit = 500,
+}: UseLinearIssueMentionsOptions = {}): UseLinearIssueMentionsReturn {
+  const [issues, setIssues] = useState<LinearIssue[]>([]);
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    if (!enabled) {
+      setIssues([]);
+      setLoading(false);
+      return;
+    }
+
+    let cancelled = false;
+    const params = new URLSearchParams();
+    params.set("limit", String(limit));
+    if (projectSlug) {
+      params.set("projectSlug", projectSlug);
+    }
+
+    setLoading(true);
+    fetch(`/api/linear/issues?${params.toString()}`)
+      .then(async (response) => {
+        const data = await response.json().catch(() => ({}));
+        if (!cancelled) {
+          setIssues(Array.isArray(data.issues) ? data.issues : []);
+        }
+      })
+      .catch(() => {
+        if (!cancelled) {
+          setIssues([]);
+        }
+      })
+      .finally(() => {
+        if (!cancelled) {
+          setLoading(false);
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, limit, projectSlug]);
+
+  return { issues, loading };
+}

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

@@ -14,10 +14,16 @@ interface Filters {
   teamId?: string;
   status?: string;
   search?: string;
+  assigneeIds?: 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,17 @@ 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.assigneeIds?.length) {
+          for (const assigneeId of filters.assigneeIds) {
+            params.append("assigneeId", 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 +77,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.assigneeIds, 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`;
+}