@mndrk/agx 2.0.42 → 2.0.45

package/cloud-runtime/standalone/lib/knowledge-store.ts

@@ -1,9 +1,7 @@
-import { createHash, randomUUID } from "crypto";
-import { getSQLiteDb } from "./sqlite-query-adapter";
-import { transactionFn } from "./sqlite-compat";
+import { vaultStore, type VaultKnowledgeDraft, type VaultKnowledgeEntry, type VaultKnowledgeEvidence } from "./vault-store";
 
-export type KnowledgeScope = "agent" | "repo" | "project";
-export type KnowledgeSourceType = "reflection" | "thread_transition" | "task_completion";
+export type KnowledgeScope = "global" | "agent" | "repo" | "project";
+export type KnowledgeSourceType = "reflection" | "thread_transition" | "task_completion" | "manual";
 export type KnowledgeKind =
   | "outcome"
   | "decision"
@@ -14,221 +12,20 @@ export type KnowledgeKind =
   | "convention"
   | "lesson";
 
-export interface KnowledgeEvidence {
-  id?: string;
-  note: string;
-}
-
-export interface KnowledgeEntry {
-  id: string;
-  scope: KnowledgeScope;
-  subjectId: string;
-  sourceType: KnowledgeSourceType;
-  sourceId: string;
-  kind: KnowledgeKind;
-  title: string;
-  body: string;
-  confidence: number | null;
-  durability: number | null;
-  tags: string[];
-  evidence: KnowledgeEvidence[];
-  metadata: Record<string, unknown>;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface KnowledgeDraft {
-  scope: KnowledgeScope;
-  subjectId: string;
-  sourceType: KnowledgeSourceType;
-  sourceId: string;
-  kind: KnowledgeKind;
-  title: string;
-  body: string;
-  confidence?: number | null;
-  durability?: number | null;
-  tags?: string[];
-  evidence?: KnowledgeEvidence[];
-  metadata?: Record<string, unknown>;
-}
-
-function clampUnitNumber(value: unknown): number | null {
-  if (typeof value !== "number" || !Number.isFinite(value)) return null;
-  return Math.max(0, Math.min(1, value));
-}
-
-function parseJsonArray<T>(raw: string | null): T[] {
-  if (!raw) return [];
-  try {
-    const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? (parsed as T[]) : [];
-  } catch {
-    return [];
-  }
-}
+export interface KnowledgeEvidence extends VaultKnowledgeEvidence {}
 
-function parseJsonObject(raw: string | null): Record<string, unknown> {
-  if (!raw) return {};
-  try {
-    const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
-      ? (parsed as Record<string, unknown>)
-      : {};
-  } catch {
-    return {};
-  }
-}
-
-function normalizeTags(tags?: string[]): string[] {
-  const seen = new Set<string>();
-  const result: string[] = [];
-  for (const tag of tags ?? []) {
-    const trimmed = String(tag ?? "").trim().toLowerCase();
-    if (!trimmed || seen.has(trimmed)) continue;
-    seen.add(trimmed);
-    result.push(trimmed);
-  }
-  return result;
-}
+export interface KnowledgeEntry extends VaultKnowledgeEntry {}
 
-function normalizeEvidence(evidence?: KnowledgeEvidence[]): KnowledgeEvidence[] {
-  const result: KnowledgeEvidence[] = [];
-  for (const item of evidence ?? []) {
-    const note = String(item?.note ?? "").trim();
-    const id = typeof item?.id === "string" ? item.id.trim() : "";
-    if (!note) continue;
-    result.push(id ? { id, note } : { note });
-  }
-  return result;
-}
-
-function mapRow(row: {
-  id: string;
-  scope: KnowledgeScope;
-  subject_id: string;
-  source_type: KnowledgeSourceType;
-  source_id: string;
-  kind: KnowledgeKind;
-  title: string;
-  body: string;
-  confidence: number | null;
-  durability: number | null;
-  tags: string | null;
-  evidence: string | null;
-  metadata: string | null;
-  created_at: string;
-  updated_at: string;
-}): KnowledgeEntry {
-  return {
-    id: row.id,
-    scope: row.scope,
-    subjectId: row.subject_id,
-    sourceType: row.source_type,
-    sourceId: row.source_id,
-    kind: row.kind,
-    title: row.title,
-    body: row.body,
-    confidence: clampUnitNumber(row.confidence),
-    durability: clampUnitNumber(row.durability),
-    tags: parseJsonArray<string>(row.tags),
-    evidence: parseJsonArray<KnowledgeEvidence>(row.evidence),
-    metadata: parseJsonObject(row.metadata),
-    createdAt: row.created_at,
-    updatedAt: row.updated_at,
-  };
-}
+export interface KnowledgeDraft extends VaultKnowledgeDraft {}
 
 export function listKnowledgeEntries(input: {
   scope: KnowledgeScope;
   subjectId: string;
   limit?: number;
 }): KnowledgeEntry[] {
-  const db = getSQLiteDb();
-  const rows = db
-    .prepare(
-      `SELECT id, scope, subject_id, source_type, source_id, kind, title, body,
-              confidence, durability, tags, evidence, metadata, created_at, updated_at
-       FROM knowledge_entries
-       WHERE scope = ? AND subject_id = ?
-       ORDER BY updated_at DESC, created_at DESC
-       LIMIT ?`
-    )
-    .all(input.scope, input.subjectId, input.limit ?? 50) as Array<{
-    id: string;
-    scope: KnowledgeScope;
-    subject_id: string;
-    source_type: KnowledgeSourceType;
-    source_id: string;
-    kind: KnowledgeKind;
-    title: string;
-    body: string;
-    confidence: number | null;
-    durability: number | null;
-    tags: string | null;
-    evidence: string | null;
-    metadata: string | null;
-    created_at: string;
-    updated_at: string;
-  }>;
-  return rows.map(mapRow);
+  return vaultStore.listKnowledgeEntries(input);
 }
 
 export function storeKnowledgeEntries(drafts: KnowledgeDraft[]): number {
-  if (drafts.length === 0) return 0;
-
-  const db = getSQLiteDb();
-  const now = new Date().toISOString();
-  const existingStmt = db.prepare(
-    `SELECT id
-     FROM knowledge_entries
-     WHERE scope = ? AND subject_id = ? AND content_hash = ?
-     LIMIT 1`
-  );
-  const insertStmt = db.prepare(
-    `INSERT INTO knowledge_entries (
-      id, scope, subject_id, source_type, source_id, kind, title, body,
-      confidence, durability, tags, evidence, metadata, content_hash, created_at, updated_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  );
-
-  let inserted = 0;
-  const tx = transactionFn(db, (entries: KnowledgeDraft[]) => {
-    for (const draft of entries) {
-      const subjectId = draft.subjectId.trim();
-      const title = draft.title.trim();
-      const body = draft.body.trim();
-      const sourceId = draft.sourceId.trim();
-      if (!subjectId || !title || !body || !sourceId) continue;
-
-      const contentHash = createHash("sha256")
-        .update(`${draft.scope}\n${subjectId}\n${body}`)
-        .digest("hex");
-
-      const existing = existingStmt.get(draft.scope, subjectId, contentHash) as { id: string } | undefined;
-      if (existing) continue;
-
-      insertStmt.run(
-        randomUUID(),
-        draft.scope,
-        subjectId,
-        draft.sourceType,
-        sourceId,
-        draft.kind,
-        title,
-        body,
-        clampUnitNumber(draft.confidence),
-        clampUnitNumber(draft.durability),
-        JSON.stringify(normalizeTags(draft.tags)),
-        JSON.stringify(normalizeEvidence(draft.evidence)),
-        JSON.stringify(draft.metadata ?? {}),
-        contentHash,
-        now,
-        now,
-      );
-      inserted += 1;
-    }
-  });
-
-  tx(drafts);
-  return inserted;
+  return vaultStore.storeKnowledgeEntries(drafts);
 }

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

@@ -0,0 +1,427 @@
+import "server-only";
+
+import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+const TOKEN_PATH = ".linear-token.json";
+const LINEAR_GRAPHQL_URL = "https://api.linear.app/graphql";
+
+interface LinearToken {
+  accessToken: string;
+  expiresAt?: number;
+}
+
+interface LinearGraphQLError {
+  message?: string;
+}
+
+interface LinearGraphQLResponse<TData> {
+  data?: TData;
+  errors?: LinearGraphQLError[];
+}
+
+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>;
+
+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 {
+  id: string;
+  number: number;
+  name: string | null;
+  startsAt: string;
+  endsAt: string;
+  teamId: string | null;
+  teamName: string | null;
+}
+
+interface RawLinearCycleNode {
+  id: string;
+  number: number;
+  name: string | null;
+  startsAt: string;
+  endsAt: string;
+  team: {
+    id: string;
+    name: string;
+  } | null;
+}
+
+interface LinearIssueConnection {
+  nodes: LinearIssueNode[];
+  pageInfo: {
+    hasNextPage: boolean;
+    endCursor: string | null;
+  };
+}
+
+function getTokenPath(): string {
+  return path.join(process.cwd(), TOKEN_PATH);
+}
+
+export function getLinearToken(): LinearToken | null {
+  try {
+    const raw = readFileSync(getTokenPath(), "utf8");
+    return JSON.parse(raw) as LinearToken;
+  } catch {
+    return null;
+  }
+}
+
+export function saveLinearToken(token: LinearToken): void {
+  writeFileSync(getTokenPath(), JSON.stringify(token, null, 2));
+}
+
+export function deleteLinearToken(): void {
+  try {
+    unlinkSync(getTokenPath());
+  } catch {
+    // already gone
+  }
+}
+
+function serializeGraphQLValue(value: unknown): string {
+  if (value === null) {
+    return "null";
+  }
+
+  if (Array.isArray(value)) {
+    return `[${value.map(serializeGraphQLValue).join(", ")}]`;
+  }
+
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+
+  if (typeof value === "object") {
+    const entries = Object.entries(value).filter(([, child]) => child !== undefined);
+    return `{ ${entries
+      .map(([key, child]) => `${key}: ${serializeGraphQLValue(child)}`)
+      .join(", ")} }`;
+  }
+
+  throw new Error(`Unsupported GraphQL value: ${typeof value}`);
+}
+
+function buildIssuesArguments(params: {
+  first: number;
+  after?: string;
+  filter?: LinearIssueFilter;
+  orderBy?: string;
+}): string {
+  const args = [`first: ${params.first}`];
+
+  if (params.after) {
+    args.push(`after: ${JSON.stringify(params.after)}`);
+  }
+
+  if (params.orderBy) {
+    args.push(`orderBy: ${params.orderBy}`);
+  }
+
+  if (params.filter && Object.keys(params.filter).length > 0) {
+    args.push(`filter: ${serializeGraphQLValue(params.filter)}`);
+  }
+
+  return args.join(", ");
+}
+
+export class LinearClient {
+  constructor(private readonly accessToken: string) {}
+
+  get viewer(): Promise<LinearViewer> {
+    return this.request<{ viewer: LinearViewer }>(
+      `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;
+    filter?: LinearIssueFilter;
+    orderBy?: string;
+  }): Promise<LinearIssueConnection> {
+    const args = buildIssuesArguments(params);
+    const data = await this.request<{
+      issues: {
+        nodes: RawLinearIssueNode[];
+        pageInfo: {
+          hasNextPage: boolean;
+          endCursor: string | null;
+        };
+      };
+    }>(
+      `query {
+        issues(${args}) {
+          nodes {
+            id
+            identifier
+            title
+            description
+            url
+            updatedAt
+            state { name }
+            assignee { id name email }
+            team { id name key }
+            cycle { id number name }
+          }
+          pageInfo {
+            hasNextPage
+            endCursor
+          }
+        }
+      }`,
+    );
+
+    return {
+      nodes: data.issues.nodes.map((issue) => ({
+        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,
+    };
+  }
+
+  async cycles(): Promise<LinearCycle[]> {
+    const data = await this.request<{
+      teams: {
+        nodes: Array<{
+          id: string;
+          name: string;
+          activeCycle: RawLinearCycleNode | null;
+          cycles: {
+            nodes: RawLinearCycleNode[];
+          };
+        }>;
+      };
+    }>(
+      `query {
+        teams(first: 50) {
+          nodes {
+            id
+            name
+            activeCycle {
+              id
+              number
+              name
+              startsAt
+              endsAt
+              team {
+                id
+                name
+              }
+            }
+            cycles(first: 20) {
+              nodes {
+                id
+                number
+                name
+                startsAt
+                endsAt
+                team {
+                  id
+                  name
+                }
+              }
+            }
+          }
+        }
+      }`,
+    );
+
+    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> {
+    const response = await fetch(LINEAR_GRAPHQL_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: this.accessToken,
+      },
+      body: JSON.stringify({ query }),
+      cache: "no-store",
+    });
+
+    const payload =
+      (await response.json()) as LinearGraphQLResponse<TData>;
+
+    if (!response.ok || payload.errors?.length) {
+      const message =
+        payload.errors?.map((error) => error.message).find(Boolean) ??
+        `Linear request failed with status ${response.status}`;
+      throw new Error(message);
+    }
+
+    if (!payload.data) {
+      throw new Error("Linear response did not include data");
+    }
+
+    return payload.data;
+  }
+}
+
+export function getLinearClient(): LinearClient | null {
+  const token = getLinearToken();
+  if (!token) return null;
+  return new LinearClient(token.accessToken);
+}