@stackmemoryai/stackmemory 1.2.1 → 1.2.4

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

@@ -0,0 +1,115 @@
+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/greptile/client.js

@@ -0,0 +1,101 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,11 @@
+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
+};

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

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

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

@@ -62,7 +62,9 @@ class LinearConfigManager {
    * Get default configuration with project isolation
    */
   getDefaultConfig() {
-    const projectId = this.isolationManager.getProjectIdentification(this.projectRoot);
+    const projectId = this.isolationManager.getProjectIdentification(
+      this.projectRoot
+    );
     return {
       enabled: true,
       interval: 5,

package/dist/src/integrations/linear/sync.js

@@ -5,7 +5,6 @@ const __dirname = __pathDirname(__filename);
 import { readFileSync, writeFileSync, existsSync } from "fs";
 import { join } from "path";
 import { logger } from "../../core/monitoring/logger.js";
-import { IntegrationError, ErrorCode } from "../../core/errors/index.js";
 import { LinearClient } from "./client.js";
 class LinearSyncEngine {
   taskStore;
@@ -15,6 +14,7 @@ class LinearSyncEngine {
   mappings = /* @__PURE__ */ new Map();
   projectRoot;
   mappingsPath;
+  _isConfigured = true;
   constructor(taskStore, authManager, config, projectRoot) {
     this.taskStore = taskStore;
     this.authManager = authManager;
@@ -33,10 +33,9 @@ class LinearSyncEngine {
     } else {
       const tokens = this.authManager.loadTokens();
       if (!tokens) {
-        throw new IntegrationError(
-          'Linear API key or authentication tokens not found. Set LINEAR_API_KEY environment variable or run "stackmemory linear setup" first.',
-          ErrorCode.LINEAR_SYNC_FAILED
-        );
+        logger.info("Linear API key not configured \u2014 skipping Linear sync");
+        this._isConfigured = false;
+        return;
       }
       this.linearClient = new LinearClient({
         apiKey: tokens.accessToken,
@@ -49,6 +48,12 @@ class LinearSyncEngine {
     }
     this.loadMappings();
   }
+  /**
+   * Check if Linear credentials are available
+   */
+  get isConfigured() {
+    return this._isConfigured;
+  }
   /**
    * Update sync configuration
    */
@@ -59,6 +64,14 @@ class LinearSyncEngine {
    * Perform bi-directional sync
    */
   async sync() {
+    if (!this._isConfigured) {
+      return {
+        success: true,
+        synced: { toLinear: 0, fromLinear: 0, updated: 0 },
+        conflicts: [],
+        errors: []
+      };
+    }
     if (!this.config.enabled) {
       return {
         success: false,

package/dist/src/integrations/linear/webhook.js

@@ -22,6 +22,7 @@ function getOptionalEnv(key) {
 class LinearWebhookHandler {
   syncEngine;
   taskStore;
+  graphitiBridge;
   webhookSecret;
   constructor(webhookSecret) {
     this.webhookSecret = webhookSecret || process.env["LINEAR_WEBHOOK_SECRET"];
@@ -38,6 +39,12 @@ class LinearWebhookHandler {
   setTaskStore(taskStore) {
     this.taskStore = taskStore;
   }
+  /**
+   * Set the Graphiti bridge for knowledge graph sync
+   */
+  setGraphitiBridge(bridge) {
+    this.graphitiBridge = bridge;
+  }
   /**
    * Verify webhook signature
    */
@@ -104,6 +111,15 @@ class LinearWebhookHandler {
       default:
         logger.warn(`Unknown webhook action: ${payload.action}`);
     }
+    if (this.graphitiBridge) {
+      this.graphitiBridge.processWebhook(payload).catch((err) => {
+        logger.debug("Linear-Graphiti bridge error", {
+          action: payload.action,
+          identifier: payload.data.identifier,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+    }
   }
   /**
    * Handle issue created in Linear

package/dist/src/integrations/mcp/handlers/code-execution-handlers.js

@@ -27,7 +27,12 @@ class CodeExecutionHandler {
    * Execute code in a controlled environment
    */
   async executeCode(params) {
-    const { language, code, workingDirectory, timeout = EXECUTION_TIMEOUT } = params;
+    const {
+      language,
+      code,
+      workingDirectory,
+      timeout = EXECUTION_TIMEOUT
+    } = params;
     if (!this.allowedLanguages.includes(language.toLowerCase())) {
       return {
         success: false,
@@ -43,7 +48,12 @@ class CodeExecutionHandler {
     );
     try {
       await fs.writeFile(tempFile, code, "utf-8");
-      const result = await this.runCode(language, tempFile, workingDirectory || this.sandboxDir, timeout);
+      const result = await this.runCode(
+        language,
+        tempFile,
+        workingDirectory || this.sandboxDir,
+        timeout
+      );
       await fs.unlink(tempFile).catch(() => {
       });
       return result;
@@ -98,8 +108,15 @@ class CodeExecutionHandler {
         clearTimeout(timeoutId);
         let outputFile;
         if (truncated) {
-          outputFile = join(this.sandboxDir, `output_${randomBytes(8).toString("hex")}.txt`);
-          await fs.writeFile(outputFile, stdout + "\n---STDERR---\n" + stderr, "utf-8").catch(() => {
+          outputFile = join(
+            this.sandboxDir,
+            `output_${randomBytes(8).toString("hex")}.txt`
+          );
+          await fs.writeFile(
+            outputFile,
+            stdout + "\n---STDERR---\n" + stderr,
+            "utf-8"
+          ).catch(() => {
           });
         }
         resolve({
@@ -175,12 +192,21 @@ class CodeExecutionHandler {
     const warnings = [];
     const dangerousPatterns = [
       { pattern: /import\s+os/i, message: "Importing os module detected" },
-      { pattern: /import\s+subprocess/i, message: "Subprocess module detected" },
+      {
+        pattern: /import\s+subprocess/i,
+        message: "Subprocess module detected"
+      },
       { pattern: /exec\s*\(/i, message: "exec() function detected" },
       { pattern: /eval\s*\(/i, message: "eval() function detected" },
       { pattern: /__import__/i, message: "__import__ detected" },
-      { pattern: /open\s*\([^)]*['"]\//i, message: "Absolute path file access detected" },
-      { pattern: /require\s*\([^)]*child_process/i, message: "child_process module detected" },
+      {
+        pattern: /open\s*\([^)]*['"]\//i,
+        message: "Absolute path file access detected"
+      },
+      {
+        pattern: /require\s*\([^)]*child_process/i,
+        message: "child_process module detected"
+      },
       { pattern: /require\s*\([^)]*fs/i, message: "fs module access detected" }
     ];
     for (const { pattern, message } of dangerousPatterns) {