@stackmemoryai/stackmemory 1.2.4 → 1.2.6

package/dist/src/integrations/graphiti/client.js

@@ -1,115 +0,0 @@
-import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __pathDirname } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __pathDirname(__filename);
-import { DEFAULT_GRAPHITI_CONFIG } from "./config.js";
-class GraphitiClientError extends Error {
-  constructor(message, code, statusCode) {
-    super(message);
-    this.code = code;
-    this.statusCode = statusCode;
-    this.name = "GraphitiClientError";
-  }
-}
-class GraphitiClient {
-  endpoint;
-  timeout;
-  maxRetries;
-  namespace;
-  constructor(config = {}) {
-    const merged = { ...DEFAULT_GRAPHITI_CONFIG, ...config };
-    this.endpoint = merged.endpoint.replace(/\/$/, "");
-    this.timeout = merged.timeoutMs;
-    this.maxRetries = merged.maxRetries;
-    this.namespace = merged.projectNamespace || "default";
-  }
-  async request(path, options = {}) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-    let lastError;
-    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
-      try {
-        const res = await fetch(`${this.endpoint}${path}`, {
-          ...options,
-          signal: controller.signal,
-          headers: {
-            "Content-Type": "application/json",
-            ...options.headers || {}
-          }
-        });
-        clearTimeout(timeoutId);
-        if (!res.ok) {
-          const msg = await res.text().catch(() => res.statusText);
-          throw new GraphitiClientError(
-            `Request failed: ${msg}`,
-            "HTTP_ERROR",
-            res.status
-          );
-        }
-        return await res.json();
-      } catch (err) {
-        lastError = err;
-        if (err instanceof GraphitiClientError) throw err;
-        if (err.name === "AbortError") {
-          throw new GraphitiClientError("Request timeout", "TIMEOUT");
-        }
-        if (attempt < this.maxRetries) {
-          await new Promise((r) => setTimeout(r, Math.pow(2, attempt) * 100));
-          continue;
-        }
-      }
-    }
-    clearTimeout(timeoutId);
-    throw new GraphitiClientError(
-      lastError?.message || "Network error",
-      "NETWORK_ERROR"
-    );
-  }
-  // Episodes
-  async upsertEpisode(episode) {
-    const payload = { ...episode, namespace: this.namespace };
-    const res = await this.request(`/episodes`, {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-    return res;
-  }
-  // Entities
-  async upsertEntities(entities) {
-    const payload = { entities, namespace: this.namespace };
-    return this.request(`/entities:batchUpsert`, {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-  }
-  // Relations
-  async upsertRelations(edges) {
-    const payload = { edges, namespace: this.namespace };
-    return this.request(`/relations:batchUpsert`, {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-  }
-  // Temporal query + hybrid retrieval
-  async queryTemporal(query) {
-    const payload = { ...query, namespace: this.namespace };
-    return this.request(`/query/temporal`, {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-  }
-  // Health/status
-  async getStatus() {
-    try {
-      return await this.request(
-        `/status?namespace=${encodeURIComponent(this.namespace)}`
-      );
-    } catch {
-      return { connected: false };
-    }
-  }
-}
-export {
-  GraphitiClient,
-  GraphitiClientError
-};

package/dist/src/integrations/graphiti/config.js

@@ -1,17 +0,0 @@
-import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __pathDirname } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __pathDirname(__filename);
-const DEFAULT_GRAPHITI_CONFIG = {
-  enabled: !!process.env.GRAPHITI_ENDPOINT,
-  endpoint: process.env.GRAPHITI_ENDPOINT?.replace(/\/$/, "") || "http://localhost:8080",
-  backend: process.env.GRAPHITI_BACKEND || "neo4j",
-  projectNamespace: process.env.STACKMEMORY_PROJECT_ID || "default",
-  timeoutMs: 5e3,
-  maxRetries: 2,
-  maxTokens: 1600,
-  maxHops: 2
-};
-export {
-  DEFAULT_GRAPHITI_CONFIG
-};

package/dist/src/integrations/graphiti/linear-graphiti-bridge.js

@@ -1,115 +0,0 @@
-import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __pathDirname } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __pathDirname(__filename);
-import { logger } from "../../core/monitoring/logger.js";
-import { GraphitiClient } from "./client.js";
-class LinearGraphitiBridge {
-  client;
-  constructor(config = {}) {
-    this.client = new GraphitiClient(config);
-  }
-  async processWebhook(payload) {
-    const { action, data } = payload;
-    const now = Date.now();
-    try {
-      const episode = {
-        type: `linear_issue_${action}`,
-        content: {
-          identifier: data.identifier,
-          title: data.title,
-          action,
-          state: data.state?.name,
-          priority: data.priority,
-          assignee: data.assignee?.name
-        },
-        timestamp: now,
-        source: "linear"
-      };
-      await this.client.upsertEpisode(episode);
-      if (action === "remove") return;
-      const entities = [
-        {
-          type: "Issue",
-          name: data.identifier,
-          summary: data.title,
-          properties: {
-            linearId: data.id,
-            state: data.state?.name,
-            priority: data.priority
-          }
-        }
-      ];
-      if (data.assignee) {
-        entities.push({
-          type: "Person",
-          name: data.assignee.name,
-          properties: {
-            linearId: data.assignee.id,
-            email: data.assignee.email
-          }
-        });
-      }
-      if (data.team) {
-        entities.push({
-          type: "Team",
-          name: data.team.name,
-          properties: { linearId: data.team.id, key: data.team.key }
-        });
-      }
-      if (data.labels?.length) {
-        for (const label of data.labels) {
-          entities.push({
-            type: "Label",
-            name: label.name,
-            properties: { linearId: label.id, color: label.color }
-          });
-        }
-      }
-      const entityResult = await this.client.upsertEntities(entities);
-      const issueId = entityResult.ids[0];
-      const relations = [];
-      let idx = 1;
-      if (data.assignee) {
-        relations.push({
-          fromId: issueId,
-          toId: entityResult.ids[idx],
-          type: "ASSIGNED_TO",
-          validFrom: now
-        });
-        idx++;
-      }
-      if (data.team) {
-        relations.push({
-          fromId: issueId,
-          toId: entityResult.ids[idx],
-          type: "BELONGS_TO",
-          validFrom: now
-        });
-        idx++;
-      }
-      if (data.labels?.length) {
-        for (let i = 0; i < data.labels.length; i++) {
-          relations.push({
-            fromId: issueId,
-            toId: entityResult.ids[idx + i],
-            type: "HAS_LABEL",
-            validFrom: now
-          });
-        }
-      }
-      if (relations.length > 0) {
-        await this.client.upsertRelations(relations);
-      }
-    } catch (error) {
-      logger.debug("Linear-Graphiti bridge error", {
-        action,
-        identifier: data.identifier,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-}
-export {
-  LinearGraphitiBridge
-};

package/dist/src/integrations/graphiti/types.js

@@ -1,4 +0,0 @@
-import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __pathDirname } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __pathDirname(__filename);