@mndrk/agx 2.0.44 → 2.0.46

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> {

package/cloud-runtime/standalone/lib/linear-issue-store.ts

@@ -0,0 +1,433 @@
+import "server-only";
+
+import { DatabaseSync } from "node:sqlite";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { pragmaSet } from "./sqlite-compat";
+
+const LINEAR_DIR =
+  process.env.AGX_LINEAR_DIR?.trim() ||
+  path.join(process.env.AGX_DATA_DIR || path.join(os.homedir(), ".agx"), "linear");
+const DB_PATH = path.join(LINEAR_DIR, "issues.sqlite");
+
+interface LinearIssueRow {
+  issue_id: string;
+  identifier: string;
+  title: string;
+  description: string | null;
+  url: string | null;
+  status: string;
+  assignee_id: string | null;
+  assignee_name: string | null;
+  assignee_email: string | null;
+  is_assigned_to_me: number;
+  team_id: string | null;
+  team_name: string | null;
+  team_key: string | null;
+  cycle_id: string | null;
+  cycle_name: string | null;
+  cycle_number: number | null;
+  updated_at: string;
+  pulled_at: number;
+}
+
+interface LinearIssueSyncStateRow {
+  scope_key: string;
+  last_pulled_at: number;
+  issue_count: number;
+}
+
+export interface CachedLinearIssueRecord {
+  id: string;
+  identifier: string;
+  title: string;
+  description: string | null;
+  url: string | null;
+  status: string;
+  assigneeId: string | null;
+  assignee: 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;
+  updatedAt: string;
+  pulledAt: string;
+}
+
+export interface CachedLinearIssueInput {
+  id: string;
+  identifier: string;
+  title: string;
+  description?: string | null;
+  url?: string | null;
+  status: string;
+  assigneeId?: string | null;
+  assignee?: 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;
+  updatedAt: string;
+}
+
+export interface LinearIssueSyncState {
+  scopeKey: string;
+  lastPulledAt: string;
+  issueCount: number;
+}
+
+export interface ListCachedLinearIssuesInput {
+  search?: string;
+  status?: string;
+  assigneeIds?: string[];
+  assignedToMe?: boolean;
+  teamId?: string;
+  cycleId?: string;
+  limit?: number;
+  cursor?: string | null;
+}
+
+export interface ListCachedLinearIssuesResult {
+  issues: CachedLinearIssueRecord[];
+  pageInfo: {
+    hasNextPage: boolean;
+    endCursor: string | null;
+  };
+}
+
+function toOptionalString(value: string | null | undefined): string | null {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+
+function toOptionalNumber(value: number | null | undefined): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+function toIso(timestampMs: number): string {
+  return new Date(timestampMs).toISOString();
+}
+
+function mapRow(row: LinearIssueRow): CachedLinearIssueRecord {
+  return {
+    id: row.issue_id,
+    identifier: row.identifier,
+    title: row.title,
+    description: row.description,
+    url: row.url,
+    status: row.status,
+    assigneeId: row.assignee_id,
+    assignee: row.assignee_name,
+    assigneeEmail: row.assignee_email,
+    isAssignedToMe: row.is_assigned_to_me === 1,
+    teamId: row.team_id,
+    teamName: row.team_name,
+    teamKey: row.team_key,
+    cycleId: row.cycle_id,
+    cycleName: row.cycle_name,
+    cycleNumber: row.cycle_number,
+    updatedAt: row.updated_at,
+    pulledAt: toIso(row.pulled_at),
+  };
+}
+
+function mapSyncState(row: LinearIssueSyncStateRow): LinearIssueSyncState {
+  return {
+    scopeKey: row.scope_key,
+    lastPulledAt: toIso(row.last_pulled_at),
+    issueCount: row.issue_count,
+  };
+}
+
+function escapeLike(value: string): string {
+  return value.replace(/[\\%_]/g, "\\$&");
+}
+
+async function withLinearIssueDatabase<T>(run: (db: DatabaseSync) => T): Promise<T> {
+  await fs.mkdir(LINEAR_DIR, { recursive: true });
+  const db = new DatabaseSync(DB_PATH);
+  pragmaSet(db, "journal_mode = WAL");
+  try {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS linear_issues (
+        issue_id TEXT PRIMARY KEY,
+        identifier TEXT NOT NULL,
+        title TEXT NOT NULL,
+        description TEXT,
+        url TEXT,
+        status TEXT NOT NULL,
+        assignee_id TEXT,
+        assignee_name TEXT,
+        assignee_email TEXT,
+        is_assigned_to_me INTEGER NOT NULL DEFAULT 0,
+        team_id TEXT,
+        team_name TEXT,
+        team_key TEXT,
+        cycle_id TEXT,
+        cycle_name TEXT,
+        cycle_number INTEGER,
+        updated_at TEXT NOT NULL,
+        pulled_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_linear_issues_updated
+        ON linear_issues (updated_at DESC, identifier ASC);
+      CREATE INDEX IF NOT EXISTS idx_linear_issues_cycle
+        ON linear_issues (cycle_id, updated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_linear_issues_assignee_me
+        ON linear_issues (is_assigned_to_me, updated_at DESC);
+      CREATE TABLE IF NOT EXISTS linear_issue_sync_state (
+        scope_key TEXT PRIMARY KEY,
+        last_pulled_at INTEGER NOT NULL,
+        issue_count INTEGER NOT NULL
+      );
+    `);
+    return run(db);
+  } finally {
+    db.close();
+  }
+}
+
+export async function replaceCachedLinearIssues(input: {
+  issues: CachedLinearIssueInput[];
+  complete: boolean;
+  pulledAtMs?: number;
+}): Promise<void> {
+  const pulledAtMs = input.pulledAtMs ?? Date.now();
+
+  return withLinearIssueDatabase((db) => {
+    db.exec("BEGIN");
+
+    try {
+      const upsert = db.prepare(`
+        INSERT INTO linear_issues (
+          issue_id, identifier, title, description, url, status,
+          assignee_id, assignee_name, assignee_email, is_assigned_to_me,
+          team_id, team_name, team_key, cycle_id, cycle_name, cycle_number,
+          updated_at, pulled_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(issue_id) DO UPDATE SET
+          identifier = excluded.identifier,
+          title = excluded.title,
+          description = excluded.description,
+          url = excluded.url,
+          status = excluded.status,
+          assignee_id = excluded.assignee_id,
+          assignee_name = excluded.assignee_name,
+          assignee_email = excluded.assignee_email,
+          is_assigned_to_me = excluded.is_assigned_to_me,
+          team_id = excluded.team_id,
+          team_name = excluded.team_name,
+          team_key = excluded.team_key,
+          cycle_id = excluded.cycle_id,
+          cycle_name = excluded.cycle_name,
+          cycle_number = excluded.cycle_number,
+          updated_at = excluded.updated_at,
+          pulled_at = excluded.pulled_at
+      `);
+
+      for (const issue of input.issues) {
+        upsert.run(
+          issue.id.trim(),
+          issue.identifier.trim(),
+          issue.title.trim(),
+          toOptionalString(issue.description ?? null),
+          toOptionalString(issue.url ?? null),
+          issue.status.trim(),
+          toOptionalString(issue.assigneeId ?? null),
+          toOptionalString(issue.assignee ?? null),
+          toOptionalString(issue.assigneeEmail ?? null),
+          issue.isAssignedToMe ? 1 : 0,
+          toOptionalString(issue.teamId ?? null),
+          toOptionalString(issue.teamName ?? null),
+          toOptionalString(issue.teamKey ?? null),
+          toOptionalString(issue.cycleId ?? null),
+          toOptionalString(issue.cycleName ?? null),
+          toOptionalNumber(issue.cycleNumber ?? null),
+          issue.updatedAt.trim(),
+          pulledAtMs
+        );
+      }
+
+      if (input.complete) {
+        if (input.issues.length === 0) {
+          db.exec("DELETE FROM linear_issues");
+        } else {
+          const placeholders = input.issues.map(() => "?").join(", ");
+          db.prepare(`DELETE FROM linear_issues WHERE issue_id NOT IN (${placeholders})`).run(
+            ...input.issues.map((issue) => issue.id.trim())
+          );
+        }
+      }
+
+      db.exec("COMMIT");
+    } catch (error) {
+      db.exec("ROLLBACK");
+      throw error;
+    }
+  });
+}
+
+export async function setLinearIssueSyncState(
+  scopeKey: string,
+  issueCount: number,
+  pulledAtMs = Date.now()
+): Promise<void> {
+  const normalizedScopeKey = scopeKey.trim() || "global";
+
+  return withLinearIssueDatabase((db) => {
+    db.prepare(`
+      INSERT INTO linear_issue_sync_state (scope_key, last_pulled_at, issue_count)
+      VALUES (?, ?, ?)
+      ON CONFLICT(scope_key) DO UPDATE SET
+        last_pulled_at = excluded.last_pulled_at,
+        issue_count = excluded.issue_count
+    `).run(normalizedScopeKey, pulledAtMs, issueCount);
+  });
+}
+
+export async function getLinearIssueSyncState(scopeKey = "global"): Promise<LinearIssueSyncState | null> {
+  const normalizedScopeKey = scopeKey.trim() || "global";
+
+  return withLinearIssueDatabase((db) => {
+    const row = db
+      .prepare(
+        `SELECT scope_key, last_pulled_at, issue_count
+         FROM linear_issue_sync_state
+         WHERE scope_key = ?
+         LIMIT 1`
+      )
+      .get(normalizedScopeKey) as LinearIssueSyncStateRow | undefined;
+
+    return row ? mapSyncState(row) : null;
+  });
+}
+
+export async function countCachedLinearIssues(): Promise<number> {
+  return withLinearIssueDatabase((db) => {
+    const row = db
+      .prepare("SELECT COUNT(*) AS count FROM linear_issues")
+      .get() as { count: number } | undefined;
+    return row?.count ?? 0;
+  });
+}
+
+export async function listCachedLinearIssues(
+  input: ListCachedLinearIssuesInput = {}
+): Promise<ListCachedLinearIssuesResult> {
+  const limit = Number.isFinite(input.limit)
+    ? Math.min(Math.max(Number(input.limit), 1), 500)
+    : 50;
+  const offset = Number.isFinite(Number(input.cursor))
+    ? Math.max(Number(input.cursor), 0)
+    : 0;
+
+  return withLinearIssueDatabase((db) => {
+    const clauses: string[] = [];
+    const params: Array<string | number> = [];
+
+    const search = toOptionalString(input.search ?? null);
+    if (search) {
+      const pattern = `%${escapeLike(search.toLowerCase())}%`;
+      clauses.push(
+        `(LOWER(identifier) LIKE ? ESCAPE '\\' OR LOWER(title) LIKE ? ESCAPE '\\' OR LOWER(COALESCE(description, '')) LIKE ? ESCAPE '\\')`
+      );
+      params.push(pattern, pattern, pattern);
+    }
+
+    const status = toOptionalString(input.status ?? null);
+    if (status) {
+      clauses.push("LOWER(status) = ?");
+      params.push(status.toLowerCase());
+    }
+
+    const assigneeIds = Array.from(
+      new Set(
+        (input.assigneeIds ?? [])
+          .map((assigneeId) => toOptionalString(assigneeId))
+          .filter((assigneeId): assigneeId is string => Boolean(assigneeId))
+      )
+    );
+    if (assigneeIds.length > 0) {
+      clauses.push(`assignee_id IN (${assigneeIds.map(() => "?").join(", ")})`);
+      params.push(...assigneeIds);
+    }
+
+    if (input.assignedToMe) {
+      clauses.push("is_assigned_to_me = 1");
+    }
+
+    const teamId = toOptionalString(input.teamId ?? null);
+    if (teamId) {
+      clauses.push("team_id = ?");
+      params.push(teamId);
+    }
+
+    const cycleId = toOptionalString(input.cycleId ?? null);
+    if (cycleId) {
+      clauses.push("cycle_id = ?");
+      params.push(cycleId);
+    }
+
+    const whereClause = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    const rows = db
+      .prepare(
+        `SELECT *
+         FROM linear_issues
+         ${whereClause}
+         ORDER BY updated_at DESC, identifier ASC
+         LIMIT ? OFFSET ?`
+      )
+      .all(...params, limit + 1, offset) as unknown as LinearIssueRow[];
+
+    const hasNextPage = rows.length > limit;
+    const pageRows = hasNextPage ? rows.slice(0, limit) : rows;
+    const endCursor = hasNextPage ? String(offset + limit) : null;
+
+    return {
+      issues: pageRows.map(mapRow),
+      pageInfo: {
+        hasNextPage,
+        endCursor,
+      },
+    };
+  });
+}
+
+export async function getCachedLinearIssueContexts(issueIds: string[]): Promise<CachedLinearIssueRecord[]> {
+  const normalizedIds = Array.from(
+    new Set(
+      issueIds
+        .map((issueId) => issueId.trim())
+        .filter(Boolean)
+    )
+  );
+
+  if (normalizedIds.length === 0) {
+    return [];
+  }
+
+  return withLinearIssueDatabase((db) => {
+    const placeholders = normalizedIds.map(() => "?").join(", ");
+    const rows = db
+      .prepare(
+        `SELECT *
+         FROM linear_issues
+         WHERE issue_id IN (${placeholders})`
+      )
+      .all(...normalizedIds) as unknown as LinearIssueRow[];
+
+    const byId = new Map(rows.map((row) => [row.issue_id, mapRow(row)]));
+    return normalizedIds
+      .map((issueId) => byId.get(issueId))
+      .filter((issue): issue is CachedLinearIssueRecord => Boolean(issue));
+  });
+}