@stackmemoryai/stackmemory 1.0.0 → 1.2.0

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

@@ -0,0 +1,104 @@
+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));
+    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)
+      });
+    }
+  }
+  // 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/hooks/schemas.js

@@ -16,6 +16,10 @@ const ModelProviderSchema = z.enum([
   "qwen",
   "openai",
   "ollama",
+  "cerebras",
+  "deepinfra",
+  "openrouter",
+  "anthropic-batch",
   "custom"
 ]);
 const ModelConfigSchema = z.object({
@@ -33,7 +37,10 @@ const ModelRouterConfigSchema = z.object({
     plan: ModelProviderSchema.optional(),
     think: ModelProviderSchema.optional(),
     code: ModelProviderSchema.optional(),
-    review: ModelProviderSchema.optional()
+    review: ModelProviderSchema.optional(),
+    linting: ModelProviderSchema.optional(),
+    context: ModelProviderSchema.optional(),
+    testing: ModelProviderSchema.optional()
   }).optional().default({}),
   fallback: z.object({
     enabled: z.boolean(),
@@ -49,6 +56,10 @@ const ModelRouterConfigSchema = z.object({
     qwen: ModelConfigSchema.optional(),
     openai: ModelConfigSchema.optional(),
     ollama: ModelConfigSchema.optional(),
+    cerebras: ModelConfigSchema.optional(),
+    deepinfra: ModelConfigSchema.optional(),
+    openrouter: ModelConfigSchema.optional(),
+    "anthropic-batch": ModelConfigSchema.optional(),
     custom: ModelConfigSchema.optional()
   }).optional().default({}),
   thinkingMode: z.object({

package/dist/src/integrations/anthropic/batch-client.js

@@ -0,0 +1,256 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { logger } from "../../core/monitoring/logger.js";
+const BATCH_JOBS_PATH = join(homedir(), ".stackmemory", "batch-jobs.json");
+const DEFAULT_POLL_INTERVAL_MS = 3e4;
+const DEFAULT_TIMEOUT_MS = 2 * 60 * 60 * 1e3;
+class AnthropicBatchClient {
+  apiKey;
+  baseUrl;
+  mockMode;
+  constructor(config) {
+    this.apiKey = config?.apiKey !== void 0 ? config.apiKey : process.env["ANTHROPIC_API_KEY"] || "";
+    this.baseUrl = config?.baseUrl || "https://api.anthropic.com";
+    this.mockMode = config?.mockMode ?? !this.apiKey;
+    if (this.mockMode) {
+      logger.warn("AnthropicBatchClient: no API key, using mock mode");
+    }
+  }
+  /**
+   * Submit a batch of requests
+   */
+  async submit(requests, description) {
+    if (this.mockMode) {
+      const batchId = `batch_mock_${Date.now()}`;
+      this.persistJob({
+        batchId,
+        status: "ended",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        requestCount: requests.length,
+        description
+      });
+      return batchId;
+    }
+    const response = await fetch(`${this.baseUrl}/v1/messages/batches`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({ requests })
+    });
+    if (!response.ok) {
+      const errText = await response.text();
+      throw new Error(`Batch submit failed: ${response.status} ${errText}`);
+    }
+    const job = await response.json();
+    this.persistJob({
+      batchId: job.id,
+      status: job.processing_status,
+      createdAt: job.created_at,
+      requestCount: requests.length,
+      description
+    });
+    logger.info("Batch submitted", { batchId: job.id, count: requests.length });
+    return job.id;
+  }
+  /**
+   * Poll batch job status
+   */
+  async poll(batchId) {
+    if (this.mockMode) {
+      return this.mockBatchJob(batchId);
+    }
+    const response = await fetch(
+      `${this.baseUrl}/v1/messages/batches/${batchId}`,
+      {
+        headers: {
+          "x-api-key": this.apiKey,
+          "anthropic-version": "2023-06-01"
+        }
+      }
+    );
+    if (!response.ok) {
+      const errText = await response.text();
+      throw new Error(`Batch poll failed: ${response.status} ${errText}`);
+    }
+    const job = await response.json();
+    this.updateJobStatus(batchId, job.processing_status, job.ended_at);
+    return job;
+  }
+  /**
+   * Retrieve batch results
+   */
+  async retrieve(batchId) {
+    if (this.mockMode) {
+      return this.mockBatchResults(batchId);
+    }
+    const job = await this.poll(batchId);
+    if (job.processing_status !== "ended") {
+      throw new Error(
+        `Batch ${batchId} not finished: ${job.processing_status}`
+      );
+    }
+    if (!job.results_url) {
+      throw new Error(`Batch ${batchId} has no results URL`);
+    }
+    const response = await fetch(job.results_url, {
+      headers: {
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Batch retrieve failed: ${response.status}`);
+    }
+    const text = await response.text();
+    return text.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
+  }
+  /**
+   * Poll until batch completes or times out
+   */
+  async waitForCompletion(batchId, timeoutMs = DEFAULT_TIMEOUT_MS, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const job = await this.poll(batchId);
+      if (job.processing_status === "ended") {
+        return job;
+      }
+      const remaining = deadline - Date.now();
+      const waitTime = Math.min(pollIntervalMs, remaining);
+      if (waitTime <= 0) break;
+      await new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(), waitTime);
+        if (typeof timer === "object" && "unref" in timer) {
+          timer.unref();
+        }
+      });
+    }
+    throw new Error(`Batch ${batchId} timed out after ${timeoutMs}ms`);
+  }
+  /**
+   * Submit and wait for results (convenience)
+   */
+  async submitAndWait(requests, timeoutMs = DEFAULT_TIMEOUT_MS, description) {
+    const batchId = await this.submit(requests, description);
+    await this.waitForCompletion(batchId, timeoutMs);
+    return this.retrieve(batchId);
+  }
+  /**
+   * Cancel a batch job
+   */
+  async cancel(batchId) {
+    if (this.mockMode) {
+      return this.mockBatchJob(batchId, "canceling");
+    }
+    const response = await fetch(
+      `${this.baseUrl}/v1/messages/batches/${batchId}/cancel`,
+      {
+        method: "POST",
+        headers: {
+          "x-api-key": this.apiKey,
+          "anthropic-version": "2023-06-01"
+        }
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Batch cancel failed: ${response.status}`);
+    }
+    const job = await response.json();
+    this.updateJobStatus(batchId, job.processing_status);
+    return job;
+  }
+  /**
+   * List stored batch jobs
+   */
+  listJobs() {
+    return this.loadStoredJobs();
+  }
+  // ── Persistence ───────────────────────────────────────────────────────
+  persistJob(job) {
+    const jobs = this.loadStoredJobs();
+    const existing = jobs.findIndex((j) => j.batchId === job.batchId);
+    if (existing >= 0) {
+      jobs[existing] = job;
+    } else {
+      jobs.push(job);
+    }
+    const trimmed = jobs.slice(-50);
+    this.saveStoredJobs(trimmed);
+  }
+  updateJobStatus(batchId, status, endedAt) {
+    const jobs = this.loadStoredJobs();
+    const job = jobs.find((j) => j.batchId === batchId);
+    if (job) {
+      job.status = status;
+      if (endedAt) job.endedAt = endedAt;
+      this.saveStoredJobs(jobs);
+    }
+  }
+  loadStoredJobs() {
+    try {
+      if (existsSync(BATCH_JOBS_PATH)) {
+        return JSON.parse(readFileSync(BATCH_JOBS_PATH, "utf8"));
+      }
+    } catch {
+    }
+    return [];
+  }
+  saveStoredJobs(jobs) {
+    try {
+      const dir = join(homedir(), ".stackmemory");
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      writeFileSync(BATCH_JOBS_PATH, JSON.stringify(jobs, null, 2));
+    } catch {
+    }
+  }
+  // ── Mock mode ─────────────────────────────────────────────────────────
+  mockBatchJob(batchId, status = "ended") {
+    return {
+      id: batchId,
+      type: "message_batch",
+      processing_status: status,
+      request_counts: {
+        processing: 0,
+        succeeded: 1,
+        errored: 0,
+        canceled: 0,
+        expired: 0
+      },
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      ended_at: status === "ended" ? (/* @__PURE__ */ new Date()).toISOString() : void 0
+    };
+  }
+  mockBatchResults(batchId) {
+    const jobs = this.loadStoredJobs();
+    const job = jobs.find((j) => j.batchId === batchId);
+    const count = job?.requestCount || 1;
+    return Array.from({ length: count }, (_, i) => ({
+      custom_id: `req_${i}`,
+      result: {
+        type: "succeeded",
+        message: {
+          id: `msg_mock_${i}`,
+          content: [
+            { type: "text", text: `Mock batch response for request ${i}` }
+          ],
+          model: "claude-sonnet-4-5-20250929",
+          stop_reason: "end_turn",
+          usage: { input_tokens: 100, output_tokens: 50 }
+        }
+      }
+    }));
+  }
+}
+export {
+  AnthropicBatchClient
+};

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

@@ -3,6 +3,7 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { logger } from "../../core/monitoring/logger.js";
+import { STRUCTURED_RESPONSE_SUFFIX } from "../../orchestrators/multimodal/constants.js";
 class AnthropicClient {
   apiKey;
   baseURL;
@@ -31,17 +32,21 @@ class AnthropicClient {
    * Send completion request to Claude
    */
   async complete(request) {
+    const enhancedRequest = {
+      ...request,
+      systemPrompt: request.systemPrompt + STRUCTURED_RESPONSE_SUFFIX
+    };
     await this.checkRateLimit();
     logger.debug("Sending completion request", {
-      model: request.model,
-      promptLength: request.prompt.length,
-      maxTokens: request.maxTokens
+      model: enhancedRequest.model,
+      promptLength: enhancedRequest.prompt.length,
+      maxTokens: enhancedRequest.maxTokens
     });
     if (!this.apiKey) {
-      return this.mockComplete(request);
+      return this.mockComplete(enhancedRequest);
     }
     try {
-      const response = await this.sendRequest(request);
+      const response = await this.sendRequest(enhancedRequest);
       return response.content;
     } catch (error) {
       logger.error("Anthropic API error", { error });
@@ -57,7 +62,9 @@ class AnthropicClient {
     } catch (error) {
       if (attempt < this.maxRetries) {
         const delay = Math.pow(2, attempt) * 1e3;
-        logger.warn(`Retrying after ${delay}ms (attempt ${attempt}/${this.maxRetries})`);
+        logger.warn(
+          `Retrying after ${delay}ms (attempt ${attempt}/${this.maxRetries})`
+        );
         await this.delay(delay);
         return this.sendRequest(request, attempt + 1);
       }
@@ -85,44 +92,48 @@ class AnthropicClient {
    * Mock response generators
    */
   mockPlanningResponse(prompt) {
-    return JSON.stringify({
-      plan: {
-        type: "sequential",
-        tasks: [
-          {
-            id: "task-1",
-            description: "Analyze requirements",
-            agent: "context",
-            dependencies: []
-          },
-          {
-            id: "task-2",
-            type: "parallel",
-            description: "Implementation phase",
-            children: [
-              {
-                id: "task-2a",
-                description: "Write core logic",
-                agent: "code",
-                dependencies: ["task-1"]
-              },
-              {
-                id: "task-2b",
-                description: "Write tests",
-                agent: "testing",
-                dependencies: ["task-1"]
-              }
-            ]
-          },
-          {
-            id: "task-3",
-            description: "Review and improve",
-            agent: "review",
-            dependencies: ["task-2"]
-          }
-        ]
-      }
-    }, null, 2);
+    return JSON.stringify(
+      {
+        plan: {
+          type: "sequential",
+          tasks: [
+            {
+              id: "task-1",
+              description: "Analyze requirements",
+              agent: "context",
+              dependencies: []
+            },
+            {
+              id: "task-2",
+              type: "parallel",
+              description: "Implementation phase",
+              children: [
+                {
+                  id: "task-2a",
+                  description: "Write core logic",
+                  agent: "code",
+                  dependencies: ["task-1"]
+                },
+                {
+                  id: "task-2b",
+                  description: "Write tests",
+                  agent: "testing",
+                  dependencies: ["task-1"]
+                }
+              ]
+            },
+            {
+              id: "task-3",
+              description: "Review and improve",
+              agent: "review",
+              dependencies: ["task-2"]
+            }
+          ]
+        }
+      },
+      null,
+      2
+    );
   }
   mockCodeResponse(prompt) {
     return `
@@ -166,34 +177,38 @@ describe('validateInput', () => {
     `.trim();
   }
   mockReviewResponse(prompt) {
-    return JSON.stringify({
-      quality: 0.75,
-      issues: [
-        "Missing error handling in processTask function",
-        "No input validation before processing",
-        "Tests could cover more edge cases"
-      ],
-      suggestions: [
-        "Add try-catch block in processTask",
-        "Validate input length and type",
-        "Add tests for special characters and long inputs",
-        "Consider adding performance tests"
-      ],
-      improvements: [
-        {
-          file: "implementation.ts",
-          line: 3,
-          suggestion: "Add input validation",
-          priority: "high"
-        },
-        {
-          file: "tests.ts",
-          line: 15,
-          suggestion: "Add edge case tests",
-          priority: "medium"
-        }
-      ]
-    }, null, 2);
+    return JSON.stringify(
+      {
+        quality: 0.75,
+        issues: [
+          "Missing error handling in processTask function",
+          "No input validation before processing",
+          "Tests could cover more edge cases"
+        ],
+        suggestions: [
+          "Add try-catch block in processTask",
+          "Validate input length and type",
+          "Add tests for special characters and long inputs",
+          "Consider adding performance tests"
+        ],
+        improvements: [
+          {
+            file: "implementation.ts",
+            line: 3,
+            suggestion: "Add input validation",
+            priority: "high"
+          },
+          {
+            file: "tests.ts",
+            line: 15,
+            suggestion: "Add edge case tests",
+            priority: "medium"
+          }
+        ]
+      },
+      null,
+      2
+    );
   }
   /**
    * Create mock response object