@mndrk/agx 2.0.47 → 2.0.49

package/cloud-runtime/standalone/lib/chat/project-context.ts

@@ -0,0 +1,169 @@
+import { type StreamProjectContext, type StreamProjectDetail } from "@/lib/stream-multiplexer";
+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 { getKnowledgeNote } from "@/lib/knowledge-notes";
+import { LOCAL_USER } from "@/lib/auth-mode";
+import type { Participant } from "@/lib/types";
+
+const PROJECT_MENTION_PATTERN = /@~project:([a-z0-9][a-z0-9-]*)/gi;
+
+export function normalizeProjectSlug(input: unknown): string {
+  if (typeof input !== "string") return "";
+  return input.trim().toLowerCase();
+}
+
+export 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,
+    })),
+  };
+}
+
+export 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;
+  }
+
+  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, "human"),
+      ]);
+      const projectSystemNote = getKnowledgeNote("project", activeProject.id);
+      if (projectSkills.length > 0) {
+        skills = projectSkills.map((skill) => ({
+          file: skill.file,
+          ...(skill.condition ? { condition: skill.condition } : {}),
+        }));
+      }
+      if (projectVars.length > 0) {
+        variables = projectVars.map((variable) => ({ key: variable.key, value: variable.value }));
+      }
+      if (projectMem.length > 0) {
+        memory = projectMem.map((entry) => ({
+          content: entry.content,
+          ...(entry.source ? { source: entry.source } : {}),
+        }));
+      }
+      if (projectSystemNote?.content) {
+        memory = [
+          ...(memory ?? []),
+          { content: projectSystemNote.content, source: "system-note" },
+        ];
+      }
+      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 (error) {
+      console.warn("Failed to load project resources", { projectId: activeProject.id, error });
+    }
+  }
+
+  return {
+    activeProject: activeProject
+      ? {
+          id: activeProject.id,
+          slug: activeProject.slug,
+          name: activeProject.name,
+        }
+      : undefined,
+    mentionedProjects: mentionedProjects.length > 0 ? mentionedProjects : undefined,
+    skills,
+    variables,
+    memory,
+    repoKnowledge,
+    provenanceByAgentId,
+  };
+}

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

@@ -1,9 +1,12 @@
 import "server-only";
 
-import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
 import path from "node:path";
 
-const TOKEN_PATH = ".linear-token.json";
+const AGX_DIR = path.join(homedir(), ".agx");
+const TOKEN_FILENAME = "linear-token.json";
+const LEGACY_TOKEN_PATH = ".linear-token.json";
 const LINEAR_GRAPHQL_URL = "https://api.linear.app/graphql";
 
 interface LinearToken {
@@ -127,19 +130,40 @@ interface LinearIssueConnection {
 }
 
 function getTokenPath(): string {
-  return path.join(process.cwd(), TOKEN_PATH);
+  return path.join(AGX_DIR, TOKEN_FILENAME);
+}
+
+function getLegacyTokenPath(): string {
+  return path.join(process.cwd(), LEGACY_TOKEN_PATH);
 }
 
 export function getLinearToken(): LinearToken | null {
+  // Try the canonical path first
   try {
     const raw = readFileSync(getTokenPath(), "utf8");
     return JSON.parse(raw) as LinearToken;
+  } catch {
+    // fall through
+  }
+
+  // Migrate from legacy cwd-relative path
+  try {
+    const legacyPath = getLegacyTokenPath();
+    const raw = readFileSync(legacyPath, "utf8");
+    const token = JSON.parse(raw) as LinearToken;
+    // Save to new location and clean up old file
+    saveLinearToken(token);
+    try { unlinkSync(legacyPath); } catch { /* ignore */ }
+    return token;
   } catch {
     return null;
   }
 }
 
 export function saveLinearToken(token: LinearToken): void {
+  if (!existsSync(AGX_DIR)) {
+    mkdirSync(AGX_DIR, { recursive: true });
+  }
   writeFileSync(getTokenPath(), JSON.stringify(token, null, 2));
 }
 
@@ -149,6 +173,12 @@ export function deleteLinearToken(): void {
   } catch {
     // already gone
   }
+  // Also clean up legacy location
+  try {
+    unlinkSync(getLegacyTokenPath());
+  } catch {
+    // already gone
+  }
 }
 
 function serializeGraphQLValue(value: unknown): string {

package/cloud-runtime/standalone/lib/linear-execution-prompt.ts

@@ -29,6 +29,26 @@ export interface LinearExecutionPromptInput {
   runtime?: LinearExecutionRuntimeContext | null;
 }
 
+export interface ResolvedLinearExecutionContext {
+  issue: {
+    identifier: string;
+    title: string;
+    status: string;
+    assignee: string;
+  };
+  project: {
+    name: string;
+    slug: string;
+    label: string;
+    repos: LinearExecutionProjectRepoContext[];
+  };
+  runtime: {
+    knowledgeBaseRoot: string;
+    issueKnowledgePath: string;
+    isolatedWorktreePath: string;
+  };
+}
+
 function slugifySegment(value: string, fallback: string): string {
   const slug = value
     .trim()
@@ -95,19 +115,14 @@ export function buildLinearExecutionPrompt(input: LinearExecutionPromptInput): {
   prompt: string;
   promptPrefix: string;
 } {
-  const issueIdentifier = input.issue.identifier.trim() || "TICKET-ID";
-  const issueTitle = input.issue.title.trim() || "Untitled ticket";
-  const issueStatus = String(input.issue.status ?? "").trim() || "Unknown";
-  const issueAssignee = String(input.issue.assignee ?? "").trim() || "Unassigned";
-  const projectSlug = toProjectSlug(input.project);
-  const knowledgeBaseRoot =
-    String(input.runtime?.knowledgeBaseRoot ?? "").trim() || `~/.agx/vault/${projectSlug}`;
-  const issueKnowledgePath =
-    String(input.runtime?.issueKnowledgePath ?? "").trim() ||
-    `${knowledgeBaseRoot}/issues/${issueIdentifier}/`;
-  const isolatedWorktreePath =
-    String(input.runtime?.isolatedWorktreePath ?? "").trim() ||
-    `/tmp/agx-${slugifySegment(issueIdentifier, "ticket")}`;
+  const context = resolveLinearExecutionContext(input);
+  const issueIdentifier = context.issue.identifier;
+  const issueTitle = context.issue.title;
+  const issueStatus = context.issue.status;
+  const issueAssignee = context.issue.assignee;
+  const knowledgeBaseRoot = context.runtime.knowledgeBaseRoot;
+  const issueKnowledgePath = context.runtime.issueKnowledgePath;
+  const isolatedWorktreePath = context.runtime.isolatedWorktreePath;
 
   const promptPrefix = [
     "LINEAR TASK EXECUTION",
@@ -118,13 +133,13 @@ export function buildLinearExecutionPrompt(input: LinearExecutionPromptInput): {
       `- Title: ${issueTitle}`,
       `- Current status: ${issueStatus}`,
       `- Current assignee: ${issueAssignee}`,
-      `- Project: ${toProjectLabel(input.project)}`,
+      `- Project: ${context.project.label}`,
       `- Knowledge base root: ${knowledgeBaseRoot}`,
       `- Issue knowledge path: ${issueKnowledgePath}`,
       `- Suggested isolated worktree: ${isolatedWorktreePath}`,
       "- Additional project resources such as repo knowledge, project memory, and project variables are injected separately by the active project context.",
     ].join("\n"),
-    `SOURCE REPOSITORIES\n${formatRepositories(input.project?.repos)}`,
+    `SOURCE REPOSITORIES\n${formatRepositories(context.project.repos)}`,
     [
       "WORKFLOW",
       "1. Read the full Linear issue and comment thread before acting. Use Linear MCP for issue details, comments, state changes, and follow-up.",
@@ -151,3 +166,65 @@ export function buildLinearExecutionPrompt(input: LinearExecutionPromptInput): {
     promptPrefix,
   };
 }
+
+export function resolveLinearExecutionContext(
+  input: LinearExecutionPromptInput
+): ResolvedLinearExecutionContext {
+  const issueIdentifier = input.issue.identifier.trim() || "TICKET-ID";
+  const issueTitle = input.issue.title.trim() || "Untitled ticket";
+  const issueStatus = String(input.issue.status ?? "").trim() || "Unknown";
+  const issueAssignee = String(input.issue.assignee ?? "").trim() || "Unassigned";
+  const projectSlug = toProjectSlug(input.project);
+  const projectName = String(input.project?.name ?? "").trim() || projectSlug;
+  const knowledgeBaseRoot =
+    String(input.runtime?.knowledgeBaseRoot ?? "").trim() || `~/.agx/vault/${projectSlug}`;
+  const issueKnowledgePath =
+    String(input.runtime?.issueKnowledgePath ?? "").trim() ||
+    `${knowledgeBaseRoot}/issues/${issueIdentifier}/`;
+  const isolatedWorktreePath =
+    String(input.runtime?.isolatedWorktreePath ?? "").trim() ||
+    `/tmp/agx-${slugifySegment(issueIdentifier, "ticket")}`;
+
+  return {
+    issue: {
+      identifier: issueIdentifier,
+      title: issueTitle,
+      status: issueStatus,
+      assignee: issueAssignee,
+    },
+    project: {
+      name: projectName,
+      slug: projectSlug,
+      label: toProjectLabel(input.project),
+      repos: input.project?.repos ? [...input.project.repos] : [],
+    },
+    runtime: {
+      knowledgeBaseRoot,
+      issueKnowledgePath,
+      isolatedWorktreePath,
+    },
+  };
+}
+
+export function renderLinearExecutionPromptTemplate(
+  template: string,
+  input: LinearExecutionPromptInput
+): string {
+  const context = resolveLinearExecutionContext(input);
+  const values: Record<string, string> = {
+    "ticket.identifier": context.issue.identifier,
+    "ticket.title": context.issue.title,
+    "ticket.status": context.issue.status,
+    "ticket.assignee": context.issue.assignee,
+    "project.name": context.project.name,
+    "project.slug": context.project.slug,
+    "project.label": context.project.label,
+    "knowledge_base.root": context.runtime.knowledgeBaseRoot,
+    "knowledge_base.issue_path": context.runtime.issueKnowledgePath,
+    "worktree.path": context.runtime.isolatedWorktreePath,
+  };
+
+  return template.replace(/\{\{\s*([a-zA-Z0-9._-]+)\s*\}\}/g, (_match, key: string) => {
+    return values[key] ?? "";
+  });
+}

package/cloud-runtime/standalone/lib/orchestrator/runtime.ts

@@ -1,6 +1,7 @@
 import { getQueue, QUEUE_NAMES } from "@/lib/queue/boss";
 import { taskProcessor } from "@/lib/orchestrator/processor";
 import { chatProcessor } from "@/lib/orchestrator/chat-processor";
+import { ensureScheduleRuntime } from "@/lib/orchestrator/schedule-runtime";
 import { writeDebugLog } from "@/lib/debug-log";
 
 let bootstrapPromise: Promise<void> | null = null;
@@ -13,6 +14,7 @@ export async function ensureOrchestratorRuntime(): Promise<void> {
     const queue = await getQueue();
     await queue.work(QUEUE_NAMES.TASK_PROCESS, taskProcessor, { batchSize: 5 });
     await queue.work(QUEUE_NAMES.CHAT_RUN_PROCESS, chatProcessor, { batchSize: 2 });
+    await ensureScheduleRuntime();
     writeDebugLog("orchestrator.bootstrap.ready", {
       queues: [QUEUE_NAMES.TASK_PROCESS, QUEUE_NAMES.CHAT_RUN_PROCESS],
     });

package/cloud-runtime/standalone/lib/orchestrator/schedule-runtime.ts

@@ -0,0 +1,76 @@
+import { writeDebugLog } from "@/lib/debug-log";
+import { createDispatchFunction } from "@/src/graph/function-executor";
+import { pollSchedules } from "@/src/graph/schedule-runner";
+import { createDispatchWork } from "@/src/graph/work-dispatcher";
+
+const DEFAULT_SCHEDULE_POLL_INTERVAL_MS = 5_000;
+
+let pollIntervalHandle: NodeJS.Timeout | null = null;
+let pollInFlight: Promise<void> | null = null;
+
+function isSchedulePollingEnabled(): boolean {
+  return process.env.AGX_DISABLE_SCHEDULE_POLLING !== "1";
+}
+
+function getSchedulePollIntervalMs(): number {
+  const raw = Number(process.env.AGX_SCHEDULE_POLL_INTERVAL_MS);
+  if (!Number.isFinite(raw)) return DEFAULT_SCHEDULE_POLL_INTERVAL_MS;
+  return Math.max(1_000, raw);
+}
+
+async function pollSchedulesOnce(): Promise<void> {
+  if (pollInFlight) {
+    return pollInFlight;
+  }
+
+  pollInFlight = (async () => {
+    const result = await pollSchedules({
+      dispatchFunction: createDispatchFunction(),
+      dispatchWork: createDispatchWork(),
+    });
+
+    if (result.errors.length > 0) {
+      writeDebugLog("schedule_runtime.poll.error", {
+        errorCount: result.errors.length,
+        graphIds: result.errors.map((entry) => entry.graphId),
+      });
+    }
+  })()
+    .catch((error) => {
+      writeDebugLog("schedule_runtime.poll.exception", { error });
+      console.error("[schedule-runtime] Poll failed:", error);
+    })
+    .finally(() => {
+      pollInFlight = null;
+    });
+
+  return pollInFlight;
+}
+
+export async function ensureScheduleRuntime(): Promise<void> {
+  if (!isSchedulePollingEnabled() || pollIntervalHandle) {
+    return;
+  }
+
+  const intervalMs = getSchedulePollIntervalMs();
+  writeDebugLog("schedule_runtime.start", { intervalMs });
+
+  pollIntervalHandle = setInterval(() => {
+    void pollSchedulesOnce();
+  }, intervalMs);
+  if (typeof pollIntervalHandle.unref === "function") {
+    pollIntervalHandle.unref();
+  }
+
+  await pollSchedulesOnce();
+}
+
+export async function stopScheduleRuntime(): Promise<void> {
+  if (pollIntervalHandle) {
+    clearInterval(pollIntervalHandle);
+    pollIntervalHandle = null;
+  }
+  if (pollInFlight) {
+    await pollInFlight;
+  }
+}