@mndrk/agx 2.0.20 → 2.0.22

package/cloud-runtime/standalone/app/api/chat/route.ts

@@ -0,0 +1,645 @@
+import { NextRequest } from "next/server";
+import {
+  createMultiplexedStream,
+  type StreamProjectContext,
+  type StreamProjectDetail,
+} from "@/lib/stream-multiplexer";
+import { loadDbParticipants } from "@/lib/agent-participants";
+import { loadHistory, saveMessages, sweepStaleWorkingReactions } from "@/lib/history-store";
+import { finalizeAttachments } from "@/lib/attachment-store";
+import { getSQLiteDb } from "@/lib/sqlite-query-adapter";
+import { db } from "@/lib/db-instance";
+import { buildExecutionProvenance, getProjectSkills, getProjectVariables, getProjectMemory } from "@/lib/db";
+import { listResolvedRepoKnowledge } from "@/lib/repo-knowledge";
+import { LOCAL_USER } from "@/lib/auth-mode";
+import { deactivateSchedulesByRootMessageId } from "@/src/graph/store";
+import type { GroupMessage, Participant } from "@/lib/types";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+interface ChatRequestBody {
+  threadId?: unknown;
+  prompt?: unknown;
+  maxRounds?: unknown;
+  userMessageId?: unknown;
+  rootMessageId?: unknown;
+  attachmentIds?: unknown;
+  activeParticipantIds?: unknown;
+  projectSlug?: unknown;
+  role?: unknown;
+  agent?: unknown;
+}
+
+const MAX_HISTORY_CHARS = 200_000;
+const SUMMARY_MARKER = "<!-- thread-summary -->";
+const CHAT_MENTION_PATTERN = /@([A-Za-z0-9_-]+)/g;
+const PROJECT_MENTION_PATTERN = /@~project:([a-z0-9][a-z0-9-]*)/gi;
+
+type ParticipantNameMap = Record<string, { name: string }>;
+
+function normalizeText(value: string): string {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+function getSpeakerLabel(message: GroupMessage, participantMap: ParticipantNameMap): string {
+  if (message.role === "user") return "User";
+  if (!message.participantId) return "Assistant";
+  return participantMap[message.participantId]?.name || message.participantId;
+}
+
+function buildHistoryContext(history: GroupMessage[], participantMap: ParticipantNameMap): string {
+  const lines: string[] = [];
+  let totalChars = 0;
+
+  // Iterate newest-first so the most recent context is always included
+  for (let i = history.length - 1; i >= 0; i--) {
+    const message = history[i];
+    const line = `${getSpeakerLabel(message, participantMap)}: ${message.content}`;
+    if (totalChars + line.length > MAX_HISTORY_CHARS) break;
+    lines.unshift(line);
+    totalChars += line.length;
+  }
+
+  if (lines.length === 0) return "";
+  return `Previous conversation (for background context only — do NOT re-discuss or repeat these topics unless the user brings them up again):\n${lines.join("\n")}`;
+}
+
+function extractThreadSummary(content: string): string | null {
+  if (!content.startsWith(SUMMARY_MARKER)) return null;
+  const text = normalizeText(content.slice(SUMMARY_MARKER.length));
+  return text || null;
+}
+
+function getMessageContextContent(message: GroupMessage): string {
+  const summary = extractThreadSummary(message.content);
+  return summary ?? message.content;
+}
+
+function toRootAlias(text: string): string | null {
+  const normalized = normalizeText(text)
+    .toLowerCase()
+    .replace(/[^a-z0-9\s_-]/g, " ")
+    .trim();
+  if (!normalized) return null;
+  const words = normalized.split(/\s+/).filter(Boolean).slice(0, 6);
+  if (words.length === 0) return null;
+  return words.join("-");
+}
+
+function getParticipantMentionTokens(participants: Participant[]): Set<string> {
+  const tokens = new Set<string>(["all"]);
+
+  for (const participant of participants) {
+    tokens.add(participant.id.toLowerCase());
+    const nameTokens = normalizeText(participant.name).toLowerCase().split(/\s+/).filter(Boolean);
+    for (const token of nameTokens) {
+      tokens.add(token);
+    }
+  }
+
+  return tokens;
+}
+
+interface ProjectRow {
+  id: string;
+  name: string;
+  slug: string;
+}
+
+interface ProjectAgentRow {
+  project_id: string;
+  agent_id: string;
+  routing_order: number;
+}
+
+function loadProjectsWithAgents(): { projects: ProjectRow[]; agentsByProject: Record<string, ProjectAgentRow[]> } {
+  try {
+    const db = getSQLiteDb();
+    const projects = db.prepare("SELECT id, name, slug FROM projects").all() as ProjectRow[];
+    const agents = db.prepare("SELECT * FROM project_agents ORDER BY routing_order ASC").all() as ProjectAgentRow[];
+    const agentsByProject: Record<string, ProjectAgentRow[]> = {};
+    for (const a of agents) {
+      (agentsByProject[a.project_id] ??= []).push(a);
+    }
+    return { projects, agentsByProject };
+  } catch {
+    return { projects: [], agentsByProject: {} };
+  }
+}
+
+function detectPromptMentions(
+  prompt: string,
+  participants: Participant[],
+  activeParticipants?: Participant[]
+): { mentioned: Set<string>; parallel: Set<string> } {
+  const mentioned = new Set<string>();
+  const parallel = new Set<string>();
+  const lower = prompt.toLowerCase();
+
+  const hasParallelAll = lower.includes("@@all");
+  const hasAll = lower.includes("@all");
+  if (hasAll || hasParallelAll) {
+    // @all only expands to active participants, not the full library
+    const allScope = activeParticipants ?? participants;
+    for (const participant of allScope) {
+      mentioned.add(participant.id);
+      if (hasParallelAll) {
+        parallel.add(participant.id);
+      }
+    }
+    return { mentioned, parallel };
+  }
+
+  // Expand @ProjectName → project member agent IDs (sequential by routing_order)
+  // @@ProjectName → parallel
+  const { projects, agentsByProject } = loadProjectsWithAgents();
+  for (const project of projects) {
+    const projectNameLower = project.name.toLowerCase();
+    const projectSlugLower = project.slug.toLowerCase();
+    const hasParallelProject = lower.includes(`@@${projectNameLower}`) || lower.includes(`@@${projectSlugLower}`);
+    const hasProject = lower.includes(`@${projectNameLower}`) || lower.includes(`@${projectSlugLower}`);
+    if (hasParallelProject || hasProject) {
+      const members = agentsByProject[project.id] ?? [];
+      for (const member of members) {
+        mentioned.add(member.agent_id);
+        if (hasParallelProject) {
+          parallel.add(member.agent_id);
+        }
+      }
+    }
+  }
+
+  // Individual @Name resolves against the full library
+  for (const participant of participants) {
+    const id = participant.id.toLowerCase();
+    const name = participant.name.toLowerCase();
+    const hasParallelMention = lower.includes(`@@${id}`) || lower.includes(`@@${name}`);
+    const hasMention = lower.includes(`@${id}`) || lower.includes(`@${name}`);
+    if (hasParallelMention || hasMention) {
+      mentioned.add(participant.id);
+      if (hasParallelMention) {
+        parallel.add(participant.id);
+      }
+    }
+  }
+
+  return { mentioned, parallel };
+}
+
+function findReferencedRootIds(
+  prompt: string,
+  participants: Participant[],
+  rootMessages: GroupMessage[]
+): string[] {
+  const mentionTokens = Array.from(prompt.matchAll(CHAT_MENTION_PATTERN), (match) =>
+    match[1].toLowerCase()
+  );
+  if (mentionTokens.length === 0 || rootMessages.length === 0) return [];
+
+  const participantTokens = getParticipantMentionTokens(participants);
+  const lookup = new Map<string, string>();
+
+  const newestRoots = [...rootMessages].sort((a, b) => b.timestamp - a.timestamp);
+  newestRoots.forEach((rootMessage, index) => {
+    lookup.set(rootMessage.id.toLowerCase(), rootMessage.id);
+    lookup.set(`chat${index + 1}`, rootMessage.id);
+    const alias = toRootAlias(rootMessage.content);
+    if (alias && !lookup.has(alias)) {
+      lookup.set(alias, rootMessage.id);
+    }
+  });
+
+  const referencedIds = new Set<string>();
+  for (const token of mentionTokens) {
+    if (participantTokens.has(token)) continue;
+    if (token.startsWith("project-")) continue;
+    const rootId = lookup.get(token);
+    if (rootId) {
+      referencedIds.add(rootId);
+    }
+  }
+
+  return Array.from(referencedIds);
+}
+
+function buildReferencedChatContext(
+  history: GroupMessage[],
+  participantMap: ParticipantNameMap,
+  referencedRootIds: string[]
+): string {
+  if (referencedRootIds.length === 0) return "";
+
+  const blocks: string[] = [];
+  for (const rootId of referencedRootIds) {
+    const root = history.find((message) => message.id === rootId);
+    if (!root) continue;
+
+    const threadMessages = history
+      .filter((message) => message.id === rootId || message.rootMessageId === rootId)
+      .sort((a, b) => a.timestamp - b.timestamp);
+    if (threadMessages.length === 0) continue;
+
+    const lines = threadMessages.map((message) => {
+      const speaker = getSpeakerLabel(message, participantMap);
+      const content = getMessageContextContent(message);
+      return `${speaker}: ${content}`;
+    });
+
+    blocks.push(
+      `Referenced chat (${root.id})\nRoot: ${normalizeText(root.content)}\n${lines.join("\n")}`
+    );
+  }
+
+  if (blocks.length === 0) return "";
+  return `Referenced chats (only because the user explicitly @mentioned them):\n\n${blocks.join("\n\n---\n\n")}`;
+}
+
+function toActiveParticipantIds(input: unknown): string[] {
+  if (!Array.isArray(input)) return [];
+
+  const seen = new Set<string>();
+  const ids: string[] = [];
+  for (const value of input) {
+    if (typeof value !== "string") continue;
+    const trimmed = value.trim();
+    if (!trimmed || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    ids.push(trimmed);
+  }
+  return ids;
+}
+
+function normalizeProjectSlug(input: unknown): string {
+  if (typeof input !== "string") return "";
+  return input.trim().toLowerCase();
+}
+
+function findProjectMentionSlugs(prompt: string): string[] {
+  const slugs = new Set<string>();
+  for (const match of prompt.matchAll(PROJECT_MENTION_PATTERN)) {
+    const slug = normalizeProjectSlug(match[1]);
+    if (slug) slugs.add(slug);
+  }
+  return Array.from(slugs);
+}
+
+function toStreamProjectDetail(project: {
+  id: string;
+  slug: string;
+  name: string;
+  description?: string | null;
+  ci_cd_info?: string | null;
+  workflow_id?: string | null;
+  repos?: Array<{ name: string; path?: string | null; notes?: string | null }>;
+}): StreamProjectDetail {
+  return {
+    id: project.id,
+    slug: project.slug,
+    name: project.name,
+    description: project.description ?? null,
+    ciCdInfo: project.ci_cd_info ?? null,
+    workflowId: project.workflow_id ?? null,
+    repos: (project.repos ?? []).map((repo) => ({
+      name: repo.name,
+      path: repo.path ?? null,
+      notes: repo.notes ?? null,
+    })),
+  };
+}
+
+async function resolveProjectContext(
+  scopedProjectSlug: string,
+  mentionedProjectSlugs: string[],
+  participants: Participant[] = []
+): Promise<StreamProjectContext | undefined> {
+  const slugsToFetch = new Set<string>();
+  if (scopedProjectSlug) slugsToFetch.add(scopedProjectSlug);
+  for (const slug of mentionedProjectSlugs) {
+    if (slug) slugsToFetch.add(slug);
+  }
+  if (slugsToFetch.size === 0) return undefined;
+
+  const rows = await Promise.all(
+    Array.from(slugsToFetch).map(async (slug) => {
+      try {
+        const project = await db.getProjectWithRepos(slug, LOCAL_USER.id);
+        return [slug, project] as const;
+      } catch (error) {
+        console.warn("Failed to load project context", { slug, error });
+        return [slug, null] as const;
+      }
+    })
+  );
+
+  const bySlug = new Map<string, NonNullable<(typeof rows)[number][1]>>();
+  for (const [slug, row] of rows) {
+    if (row) bySlug.set(slug, row);
+  }
+
+  const activeProject = scopedProjectSlug ? bySlug.get(scopedProjectSlug) : undefined;
+  const mentionedProjects = mentionedProjectSlugs
+    .map((slug) => bySlug.get(slug))
+    .filter((project): project is NonNullable<typeof project> => Boolean(project))
+    .map((project) => toStreamProjectDetail(project));
+
+  if (!activeProject && mentionedProjects.length === 0) {
+    return undefined;
+  }
+
+  // Load project-level resources for the active project (skills, variables, memory)
+  let skills: Array<{ file: string; condition?: string }> | undefined;
+  let variables: Array<{ key: string; value: string }> | undefined;
+  let memory: Array<{ content: string; source?: string }> | undefined;
+  let repoKnowledge: StreamProjectContext["repoKnowledge"];
+  let provenanceByAgentId: StreamProjectContext["provenanceByAgentId"];
+
+  if (activeProject) {
+    try {
+      const [projectSkills, projectVars, projectMem] = await Promise.all([
+        getProjectSkills(activeProject.id),
+        getProjectVariables(activeProject.id),
+        getProjectMemory(activeProject.id),
+      ]);
+      if (projectSkills.length > 0) {
+        skills = projectSkills.map((s) => ({ file: s.file, ...(s.condition ? { condition: s.condition } : {}) }));
+      }
+      if (projectVars.length > 0) {
+        variables = projectVars.map((v) => ({ key: v.key, value: v.value }));
+      }
+      if (projectMem.length > 0) {
+        memory = projectMem.map((m) => ({ content: m.content, ...(m.source ? { source: m.source } : {}) }));
+      }
+      const resolvedRepoKnowledge = listResolvedRepoKnowledge(activeProject.repos ?? []).map((entry) => ({
+        repoName: entry.repoName,
+        path: entry.path ?? null,
+        content:
+          entry.producer === "system"
+            ? `[System-generated] ${entry.content}`
+            : entry.content,
+      }));
+      if (resolvedRepoKnowledge.length > 0) {
+        repoKnowledge = resolvedRepoKnowledge;
+      }
+      if (participants.length > 0) {
+        const sqlite = getSQLiteDb();
+        provenanceByAgentId = {};
+        for (const participant of participants) {
+          const agentMemoryEntries = sqlite
+            .prepare(
+              "SELECT id, content FROM agent_memory WHERE agent_id = ? ORDER BY created_at DESC LIMIT 20"
+            )
+            .all(participant.id) as Array<{ id: string; content: string }>;
+          provenanceByAgentId[participant.id] = await buildExecutionProvenance(
+            participant.id,
+            activeProject.id,
+            participant.skills ?? [],
+            agentMemoryEntries
+          );
+        }
+      }
+    } catch (e) {
+      console.warn("Failed to load project resources", { projectId: activeProject.id, error: e });
+    }
+  }
+
+  return {
+    activeProject: activeProject
+      ? {
+          id: activeProject.id,
+          slug: activeProject.slug,
+          name: activeProject.name,
+        }
+      : undefined,
+    mentionedProjects: mentionedProjects.length > 0 ? mentionedProjects : undefined,
+    skills,
+    variables,
+    memory,
+    repoKnowledge,
+    provenanceByAgentId,
+  };
+}
+
+export async function POST(request: NextRequest) {
+  const body = (await request.json().catch(() => ({}))) as ChatRequestBody;
+  const prompt =
+    typeof body.prompt === "string"
+      ? body.prompt.trim()
+      : "";
+  const threadId =
+    typeof body.threadId === "string"
+      ? body.threadId.trim()
+      : "";
+  const scopedProjectSlug = normalizeProjectSlug(body.projectSlug);
+
+  if (!threadId) {
+    return new Response(JSON.stringify({ error: "threadId is required" }), {
+      status: 400,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+
+  if (!prompt) {
+    return new Response(JSON.stringify({ error: "No prompt provided" }), {
+      status: 400,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+
+  const participantLibrary = await loadDbParticipants();
+  const hasActiveFilter = Array.isArray(body.activeParticipantIds);
+  const requestedActiveIds = toActiveParticipantIds(body.activeParticipantIds);
+  const activeIdSet = hasActiveFilter ? new Set(requestedActiveIds) : null;
+
+  const filteredParticipants =
+    activeIdSet === null
+      ? participantLibrary
+      : participantLibrary.filter((participant) => activeIdSet.has(participant.id));
+  // Recover from stale stored active IDs: if a non-empty filter resolves to nothing,
+  // fall back to the full participant library so chat still works.
+  const baseParticipants =
+    activeIdSet !== null && requestedActiveIds.length > 0 && filteredParticipants.length === 0
+      ? participantLibrary
+      : filteredParticipants;
+
+  // @Name resolves against the full library (lets users wake an inactive agent).
+  // @all only expands to the active participants — not the full library.
+  const { mentioned, parallel: parallelMentioned } = detectPromptMentions(prompt, participantLibrary, baseParticipants);
+
+  const selectedIds = new Set(baseParticipants.map((participant) => participant.id));
+  for (const id of mentioned) selectedIds.add(id);
+
+  // Preserve activeParticipantIds order so the first (primary) agent in the
+  // sidebar becomes allParticipants[0] — the default responder when no agent
+  // is explicitly mentioned.
+  const allParticipantsUnsorted = participantLibrary.filter((participant) => selectedIds.has(participant.id));
+  const orderIndex = new Map(requestedActiveIds.map((id, i) => [id, i]));
+  const allParticipants = allParticipantsUnsorted.sort((a, b) => {
+    const ai = orderIndex.get(a.id) ?? Number.MAX_SAFE_INTEGER;
+    const bi = orderIndex.get(b.id) ?? Number.MAX_SAFE_INTEGER;
+    return ai - bi;
+  });
+
+  if (allParticipants.length === 0) {
+    return new Response(JSON.stringify({ error: "No active agents configured for this project" }), {
+      status: 400,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+
+  const projectContext = await resolveProjectContext(
+    scopedProjectSlug,
+    findProjectMentionSlugs(prompt),
+    allParticipants
+  );
+  const now = Date.now();
+  const rawUserMessageId =
+    typeof body.userMessageId === "string"
+      ? body.userMessageId.trim()
+      : "";
+  const userMessageId = rawUserMessageId || crypto.randomUUID();
+  const explicitRootMessageId =
+    typeof body.rootMessageId === "string"
+      ? body.rootMessageId.trim() || null
+      : null;
+
+  // Load conversation history for context.
+  await sweepStaleWorkingReactions(threadId);
+  const history = await loadHistory(threadId);
+  const participantMap: ParticipantNameMap = Object.fromEntries(
+    participantLibrary.map((p) => [p.id, { name: p.name }])
+  );
+
+  const rootMessages = history.filter(
+    (message) =>
+      message.role === "user" &&
+      !message.rootMessageId &&
+      message.id !== (explicitRootMessageId || "")
+  );
+  const referencedRootIds = explicitRootMessageId
+    ? findReferencedRootIds(prompt, participantLibrary, rootMessages)
+    : [];
+
+  const subthreadHistory = history.filter(
+    (message) => message.id === explicitRootMessageId || message.rootMessageId === explicitRootMessageId
+  );
+  const contextHistory = subthreadHistory;
+  const historyContext = buildHistoryContext(contextHistory, participantMap);
+  const referencedChatContext = buildReferencedChatContext(
+    history,
+    participantMap,
+    referencedRootIds
+  );
+  const promptContext = [historyContext, referencedChatContext].filter(Boolean).join("\n\n---\n\n");
+
+  // Save user message — main chat messages are roots (depth 0, no rootMessageId),
+  // thread replies reference their root.
+  const requestedRole = body.role === "agent" ? "assistant" : "user";
+  const requestedAgent =
+    requestedRole === "assistant" && typeof body.agent === "string"
+      ? body.agent.trim() || null
+      : null;
+  // Resolve agent participantId: match by slug/id against the participant library.
+  const resolvedParticipantId =
+    requestedRole === "assistant"
+      ? (requestedAgent
+          ? (participantLibrary.find(
+              (p) => p.id === requestedAgent || p.name.toLowerCase() === requestedAgent.toLowerCase()
+            )?.id ?? requestedAgent)
+          : allParticipants[0]?.id ?? null)
+      : null;
+  const userMessage: GroupMessage = {
+    id: userMessageId,
+    role: requestedRole,
+    participantId: resolvedParticipantId,
+    content: prompt,
+    timestamp: now,
+    rootMessageId: explicitRootMessageId,
+    parentMessageId: explicitRootMessageId,
+    depth: explicitRootMessageId ? 1 : 0,
+  };
+  await saveMessages(threadId, [userMessage]);
+
+  // Only deactivate ship mode when the USER sends a message, not agent-role steering
+  if (explicitRootMessageId && requestedRole === "user") {
+    try {
+      deactivateSchedulesByRootMessageId(explicitRootMessageId);
+    } catch (error) {
+      console.warn("Failed to deactivate autonomous schedule on user composer message", {
+        rootMessageId: explicitRootMessageId,
+        error,
+      });
+    }
+  }
+
+  // Finalize attachments if provided
+  const rawAttachmentIds = Array.isArray(body.attachmentIds) ? body.attachmentIds.filter((id): id is string => typeof id === "string") : [];
+  let attachmentContext = "";
+  if (rawAttachmentIds.length > 0) {
+    const finalized = await finalizeAttachments(userMessageId, rawAttachmentIds);
+    if (finalized.length > 0) {
+      const lines = finalized.map((a) => `- ${a.filename} (${a.mimeType}, ${a.size} bytes): ${a.diskPath}`);
+      attachmentContext = `\n\n[Attached files]\n${lines.join("\n")}\n`;
+    }
+  }
+
+  // Agent replies always go into the thread.
+  // If user sent a main-chat message, agents reply to that message (userMessageId is the root).
+  // If user replied in a thread, agents reply in that same thread.
+  const agentRootMessageId = explicitRootMessageId || userMessageId;
+
+  const maxRounds = Math.min(
+    Math.max(Number(body.maxRounds) || 10, 1),
+    50
+  );
+
+  const fullPrompt = promptContext
+    ? `${promptContext}\n\n---\nCurrent user message:\n${prompt}${attachmentContext}`
+    : `${prompt}${attachmentContext}`;
+
+  // Extract recent assistant messages for dedup and recent messages for reaction targeting.
+  const recentTargetableMessages = subthreadHistory
+    .slice(-20)
+    .map((m) => ({
+      id: m.id,
+      name:
+        m.role === "user"
+          ? "User"
+          : m.participantId
+            ? participantMap[m.participantId]?.name || m.participantId
+            : "Assistant",
+      content: m.content,
+    }));
+
+  // Fire-and-forget: kick off the multiplexer in the background.
+  // Messages and reactions are persisted to DB by the multiplexer;
+  // the client polls /api/history?since= to pick them up.
+  const streamPromise = createMultiplexedStream({
+    threadId,
+    allParticipants,
+    mentioned,
+    initialParallelIds: parallelMentioned,
+    prompt: fullPrompt,
+    projectContext,
+    signal: undefined,
+    maxRounds,
+    recentHistory: recentTargetableMessages,
+    currentUserMessageId: userMessageId,
+    rootMessageId: agentRootMessageId,
+  });
+
+  // Drain the stream in the background so it runs to completion
+  void (async () => {
+    try {
+      const reader = streamPromise.getReader();
+      while (true) {
+        const { done } = await reader.read();
+        if (done) break;
+      }
+    } catch (err) {
+      console.error("[chat] background stream error:", err);
+    }
+  })();
+
+  return Response.json({ ok: true, userMessageId });
+}

package/cloud-runtime/standalone/app/api/migrate/teams-to-projects/route.ts

@@ -0,0 +1,4 @@
+export { GET, POST } from "@/app/api/migrate/workspaces-to-projects/route";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";