@stackmemoryai/stackmemory 1.10.5 → 1.14.0

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

@@ -1,208 +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_DIFFMEM_CONFIG } from "./config.js";
-class DiffMemClientError extends Error {
-  constructor(message, code, statusCode) {
-    super(message);
-    this.code = code;
-    this.statusCode = statusCode;
-    this.name = "DiffMemClientError";
-  }
-}
-class DiffMemClient {
-  endpoint;
-  userId;
-  timeout;
-  maxRetries;
-  constructor(config = {}) {
-    const mergedConfig = { ...DEFAULT_DIFFMEM_CONFIG, ...config };
-    this.endpoint = mergedConfig.endpoint.replace(/\/$/, "");
-    this.userId = mergedConfig.userId;
-    this.timeout = mergedConfig.timeout;
-    this.maxRetries = mergedConfig.maxRetries;
-  }
-  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 response = await fetch(`${this.endpoint}${path}`, {
-          ...options,
-          signal: controller.signal,
-          headers: {
-            "Content-Type": "application/json",
-            ...options.headers
-          }
-        });
-        clearTimeout(timeoutId);
-        if (!response.ok) {
-          const _errorBody = await response.text().catch(() => "");
-          throw new DiffMemClientError(
-            `Request failed: ${response.statusText}`,
-            "HTTP_ERROR",
-            response.status
-          );
-        }
-        return await response.json();
-      } catch (error) {
-        lastError = error;
-        if (error instanceof DiffMemClientError) {
-          throw error;
-        }
-        if (error.name === "AbortError") {
-          throw new DiffMemClientError("Request timeout", "TIMEOUT");
-        }
-        if (attempt < this.maxRetries) {
-          await new Promise(
-            (resolve) => setTimeout(resolve, Math.pow(2, attempt) * 100)
-          );
-          continue;
-        }
-      }
-    }
-    clearTimeout(timeoutId);
-    throw new DiffMemClientError(
-      lastError?.message || "Request failed after retries",
-      "NETWORK_ERROR"
-    );
-  }
-  /**
-   * Get user context/memories from DiffMem
-   * Maps to POST /memory/{user_id}/context
-   */
-  async getMemories(query = {}) {
-    try {
-      const conversation = query.query ? [{ role: "user", content: query.query }] : [{ role: "user", content: "What do you know about me?" }];
-      const response = await this.request(`/memory/${this.userId}/context`, {
-        method: "POST",
-        body: JSON.stringify({
-          conversation,
-          depth: "wide"
-        })
-      });
-      if (response.entities) {
-        return response.entities.slice(0, query.limit || 10).map((entity) => ({
-          id: entity.id,
-          content: entity.content,
-          category: "project_knowledge",
-          confidence: entity.score || 0.7,
-          timestamp: Date.now()
-        }));
-      }
-      return [];
-    } catch {
-      return [];
-    }
-  }
-  /**
-   * Store an insight/learning in DiffMem
-   * Maps to POST /memory/{user_id}/process-and-commit
-   */
-  async storeInsight(insight) {
-    const response = await this.request(`/memory/${this.userId}/process-and-commit`, {
-      method: "POST",
-      body: JSON.stringify({
-        memory_input: `[${insight.category}] ${insight.content}`,
-        session_id: `sm-${Date.now()}`,
-        session_date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
-      })
-    });
-    return { id: response.session_id || `insight-${Date.now()}` };
-  }
-  /**
-   * Search memories in DiffMem
-   * Maps to POST /memory/{user_id}/search
-   */
-  async search(query) {
-    try {
-      const response = await this.request(`/memory/${this.userId}/search`, {
-        method: "POST",
-        body: JSON.stringify({
-          query: query.query || "",
-          k: query.limit || 10
-        })
-      });
-      if (response.results) {
-        return response.results.map((result) => ({
-          id: result.snippet.id,
-          content: result.snippet.content,
-          category: "project_knowledge",
-          confidence: result.score,
-          timestamp: Date.now(),
-          metadata: { filePath: result.snippet.file_path }
-        }));
-      }
-      return [];
-    } catch {
-      return [];
-    }
-  }
-  /**
-   * Get DiffMem server status
-   * Maps to GET /health
-   */
-  async getStatus() {
-    try {
-      const health = await this.request("/health", { method: "GET" });
-      return {
-        connected: health.status === "healthy",
-        memoryCount: health.active_contexts || 0,
-        lastSync: Date.now(),
-        version: health.version
-      };
-    } catch {
-      return {
-        connected: false,
-        memoryCount: 0,
-        lastSync: null
-      };
-    }
-  }
-  /**
-   * Batch sync multiple insights
-   * Processes each insight individually since DiffMem doesn't have batch API
-   */
-  async batchSync(insights) {
-    if (insights.length === 0) {
-      return { synced: 0, failed: 0 };
-    }
-    let synced = 0;
-    let failed = 0;
-    for (const insight of insights) {
-      try {
-        await this.storeInsight(insight);
-        synced++;
-      } catch {
-        failed++;
-      }
-    }
-    return { synced, failed };
-  }
-  /**
-   * Onboard a new user in DiffMem
-   */
-  async onboardUser(userInfo) {
-    try {
-      const response = await this.request(
-        `/memory/${this.userId}/onboard`,
-        {
-          method: "POST",
-          body: JSON.stringify({
-            user_info: userInfo,
-            session_id: `onboard-${Date.now()}`
-          })
-        }
-      );
-      return { success: response.status === "success" };
-    } catch {
-      return { success: false };
-    }
-  }
-}
-export {
-  DiffMemClient,
-  DiffMemClientError
-};

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

@@ -1,14 +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_DIFFMEM_CONFIG = {
-  endpoint: process.env.DIFFMEM_ENDPOINT || "http://localhost:8000",
-  userId: process.env.DIFFMEM_USER_ID || "default",
-  timeout: 5e3,
-  maxRetries: 3,
-  enabled: process.env.DIFFMEM_ENABLED === "true" || !!process.env.DIFFMEM_ENDPOINT
-};
-export {
-  DEFAULT_DIFFMEM_CONFIG
-};

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

@@ -1,101 +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 { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { DEFAULT_GREPTILE_CONFIG } from "./config.js";
-class GreptileClientError extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "GreptileClientError";
-  }
-}
-class GreptileClient {
-  config;
-  client = null;
-  transport = null;
-  connecting = null;
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_GREPTILE_CONFIG, ...config };
-    if (!this.config.enabled || !this.config.apiKey) {
-      throw new GreptileClientError(
-        "Greptile integration disabled (GREPTILE_API_KEY not set)",
-        "DISABLED"
-      );
-    }
-  }
-  async ensureConnected() {
-    if (this.client) return this.client;
-    if (this.connecting) {
-      await this.connecting;
-      return this.client;
-    }
-    this.connecting = this.connect();
-    try {
-      await this.connecting;
-      return this.client;
-    } finally {
-      this.connecting = null;
-    }
-  }
-  async connect() {
-    const transport = new StreamableHTTPClientTransport(
-      new URL(this.config.mcpEndpoint),
-      {
-        requestInit: {
-          headers: {
-            Authorization: `Bearer ${this.config.apiKey}`
-          }
-        },
-        reconnectionOptions: {
-          maxRetries: this.config.maxRetries,
-          initialReconnectionDelay: 1e3,
-          reconnectionDelayGrowFactor: 1.5,
-          maxReconnectionDelay: 1e4
-        }
-      }
-    );
-    const client = new Client(
-      { name: "stackmemory-greptile", version: "1.0.0" },
-      { capabilities: {} }
-    );
-    transport.onclose = () => {
-      this.client = null;
-      this.transport = null;
-    };
-    await client.connect(transport);
-    this.client = client;
-    this.transport = transport;
-  }
-  async callTool(name, args = {}) {
-    const client = await this.ensureConnected();
-    const result = await client.callTool({ name, arguments: args });
-    if (result.content && Array.isArray(result.content)) {
-      const textParts = result.content.filter(
-        (c) => c.type === "text" && typeof c.text === "string"
-      ).map((c) => c.text);
-      if (textParts.length === 0) return result;
-      const combined = textParts.join("\n");
-      try {
-        return JSON.parse(combined);
-      } catch {
-        return combined;
-      }
-    }
-    return result;
-  }
-  async disconnect() {
-    if (this.transport) {
-      await this.transport.close();
-    }
-    this.client = null;
-    this.transport = null;
-    this.connecting = null;
-  }
-}
-export {
-  GreptileClient,
-  GreptileClientError
-};

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

@@ -1,14 +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_GREPTILE_CONFIG = {
-  enabled: !!process.env.GREPTILE_API_KEY,
-  mcpEndpoint: process.env.GREPTILE_MCP_ENDPOINT || "https://api.greptile.com/mcp",
-  apiKey: process.env.GREPTILE_API_KEY || "",
-  timeoutMs: 15e3,
-  maxRetries: 2
-};
-export {
-  DEFAULT_GREPTILE_CONFIG
-};

package/dist/src/integrations/greptile/index.js

@@ -1,11 +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_GREPTILE_CONFIG } from "./config.js";
-import { GreptileClient, GreptileClientError } from "./client.js";
-export {
-  DEFAULT_GREPTILE_CONFIG,
-  GreptileClient,
-  GreptileClientError
-};