@stackmemoryai/stackmemory 1.2.4 → 1.2.7

package/dist/src/hooks/graphiti-hooks.js

@@ -1,253 +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 "../integrations/graphiti/client.js";
-import { DEFAULT_GRAPHITI_CONFIG } from "../integrations/graphiti/config.js";
-class GraphitiHooks {
-  client;
-  config;
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_GRAPHITI_CONFIG, ...config };
-    this.client = new GraphitiClient(this.config);
-  }
-  register(emitter) {
-    if (!this.config.enabled) {
-      logger.debug("Graphiti hooks disabled");
-      return;
-    }
-    emitter.registerHandler("session_start", this.onSessionStart.bind(this));
-    emitter.registerHandler("file_change", this.onFileChange.bind(this));
-    emitter.registerHandler("session_end", this.onSessionEnd.bind(this));
-    emitter.registerHandler("input_idle", this.onInputIdle.bind(this));
-    emitter.registerHandler("context_switch", this.onContextSwitch.bind(this));
-    emitter.registerHandler("prompt_submit", this.onPromptSubmit.bind(this));
-    emitter.registerHandler("tool_use", this.onToolUse.bind(this));
-    emitter.registerHandler(
-      "suggestion_ready",
-      this.onSuggestionReady.bind(this)
-    );
-    emitter.registerHandler("agent_start", this.onAgentStart.bind(this));
-    emitter.registerHandler("agent_complete", this.onAgentComplete.bind(this));
-    emitter.registerHandler("agent_error", this.onAgentError.bind(this));
-    logger.info("Graphiti hooks registered", {
-      endpoint: this.config.endpoint,
-      backend: this.config.backend,
-      maxHops: this.config.maxHops
-    });
-  }
-  async onSessionStart(event) {
-    try {
-      const status = await this.client.getStatus();
-      if (!status.connected) {
-        logger.warn("Graphiti not available - operating in degraded mode");
-        return;
-      }
-      const episode = {
-        type: "session_start",
-        content: event.data || {},
-        timestamp: Date.now(),
-        source: "stackmemory",
-        metadata: { severity: "info" }
-      };
-      await this.client.upsertEpisode(episode);
-    } catch (error) {
-      logger.debug("Graphiti session_start failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  async onFileChange(event) {
-    const fileEvent = event;
-    try {
-      const episode = {
-        type: "file_change",
-        content: {
-          path: fileEvent.data.path,
-          changeType: fileEvent.data.changeType,
-          size: typeof fileEvent.data.content === "string" ? fileEvent.data.content.length : void 0
-        },
-        timestamp: Date.now(),
-        source: "stackmemory"
-      };
-      await this.client.upsertEpisode(episode);
-    } catch (error) {
-      logger.debug("Graphiti file_change episode failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  async onSessionEnd(event) {
-    try {
-      const episode = {
-        type: "session_end",
-        content: event.data || {},
-        timestamp: Date.now(),
-        source: "stackmemory"
-      };
-      await this.client.upsertEpisode(episode);
-    } catch (error) {
-      logger.debug("Graphiti session_end failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  async onInputIdle(event) {
-    const idle = event;
-    try {
-      const episode = {
-        type: "input_idle",
-        content: {
-          idleDuration: idle.data.idleDuration,
-          lastInput: idle.data.lastInput
-        },
-        timestamp: Date.now(),
-        source: "stackmemory"
-      };
-      await this.client.upsertEpisode(episode);
-    } catch (error) {
-      logger.debug("Graphiti input_idle episode failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  async onContextSwitch(event) {
-    const ctx = event;
-    try {
-      const episode = {
-        type: "context_switch",
-        content: {
-          fromBranch: ctx.data.fromBranch,
-          toBranch: ctx.data.toBranch,
-          fromProject: ctx.data.fromProject,
-          toProject: ctx.data.toProject
-        },
-        timestamp: Date.now(),
-        source: "stackmemory"
-      };
-      await this.client.upsertEpisode(episode);
-    } catch (error) {
-      logger.debug("Graphiti context_switch episode failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  async onPromptSubmit(event) {
-    try {
-      const episode = {
-        type: "prompt_submit",
-        content: event.data || {},
-        timestamp: Date.now(),
-        source: "stackmemory"
-      };
-      await this.client.upsertEpisode(episode);
-    } catch (error) {
-      logger.debug("Graphiti prompt_submit episode failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  async onToolUse(event) {
-    try {
-      const episode = {
-        type: "tool_use",
-        content: event.data || {},
-        timestamp: Date.now(),
-        source: "stackmemory"
-      };
-      await this.client.upsertEpisode(episode);
-    } catch (error) {
-      logger.debug("Graphiti tool_use episode failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  async onSuggestionReady(event) {
-    const suggestion = event;
-    try {
-      const episode = {
-        type: "suggestion_ready",
-        content: {
-          source: suggestion.data.source,
-          confidence: suggestion.data.confidence,
-          preview: suggestion.data.preview
-        },
-        timestamp: Date.now(),
-        source: "stackmemory"
-      };
-      await this.client.upsertEpisode(episode);
-    } catch (error) {
-      logger.debug("Graphiti suggestion_ready episode failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  async onAgentStart(event) {
-    const e = event;
-    try {
-      const episode = {
-        type: "agent_start",
-        content: { agentType: e.data.agentType, task: e.data.task },
-        timestamp: Date.now(),
-        source: "stackmemory"
-      };
-      await this.client.upsertEpisode(episode);
-    } catch (error) {
-      logger.debug("Graphiti agent_start episode failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  async onAgentComplete(event) {
-    const e = event;
-    try {
-      const episode = {
-        type: "agent_complete",
-        content: { ...e.data },
-        timestamp: Date.now(),
-        source: "stackmemory"
-      };
-      await this.client.upsertEpisode(episode);
-    } catch (error) {
-      logger.debug("Graphiti agent_complete episode failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  async onAgentError(event) {
-    const e = event;
-    try {
-      const episode = {
-        type: "agent_error",
-        content: { agentType: e.data.agentType, error: e.data.error },
-        timestamp: Date.now(),
-        source: "stackmemory"
-      };
-      await this.client.upsertEpisode(episode);
-    } catch (error) {
-      logger.debug("Graphiti agent_error episode failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  // Expose a simple temporal query helper for future MCP tooling
-  async buildTemporalContext(query = {}) {
-    const now = Date.now();
-    const q = {
-      query: query.query || void 0,
-      entityTypes: query.entityTypes || void 0,
-      relationTypes: query.relationTypes || void 0,
-      validFrom: query.validFrom ?? now - 1e3 * 60 * 60 * 24 * 30,
-      // 30d default
-      validTo: query.validTo ?? now,
-      maxHops: query.maxHops ?? this.config.maxHops,
-      k: query.k ?? 20,
-      rerank: query.rerank ?? true
-    };
-    return this.client.queryTemporal(q);
-  }
-}
-export {
-  GraphitiHooks
-};

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);