@stackmemoryai/stackmemory 1.0.1 → 1.2.0

package/dist/src/core/extensions/provider-adapter.js

@@ -27,12 +27,7 @@ class ClaudeAdapter {
     const body = this.buildRequestBody(messages, options);
     const response = await fetch(`${this.baseUrl}/v1/messages`, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": this.apiKey,
-        "anthropic-version": "2023-06-01",
-        "anthropic-beta": this.getBetaFlags(options.extensions)
-      },
+      headers: this.getHeaders(options.extensions),
       body: JSON.stringify({ ...body, stream: true })
     });
     if (!response.ok) {
@@ -78,12 +73,7 @@ class ClaudeAdapter {
     const body = this.buildRequestBody(messages, options);
     const response = await fetch(`${this.baseUrl}/v1/messages`, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": this.apiKey,
-        "anthropic-version": "2023-06-01",
-        "anthropic-beta": this.getBetaFlags(options.extensions)
-      },
+      headers: this.getHeaders(options.extensions),
       body: JSON.stringify(body)
     });
     if (!response.ok) {
@@ -166,7 +156,12 @@ class ClaudeAdapter {
     }
     return body;
   }
-  getBetaFlags(extensions) {
+  getHeaders(extensions) {
+    const headers = {
+      "Content-Type": "application/json",
+      "x-api-key": this.apiKey,
+      "anthropic-version": "2023-06-01"
+    };
     const flags = [];
     if (extensions?.extendedThinking?.enabled) {
       flags.push("interleaved-thinking-2025-05-14");
@@ -177,7 +172,10 @@ class ClaudeAdapter {
     if (extensions?.documentSupport?.enabled) {
       flags.push("pdfs-2024-09-25");
     }
-    return flags.join(",");
+    if (flags.length > 0) {
+      headers["anthropic-beta"] = flags.join(",");
+    }
+    return headers;
   }
   normalizeEvent(event) {
     return event;
@@ -374,240 +372,35 @@ class GPTAdapter {
     ];
   }
 }
-class GeminiAdapter {
-  id = "gemini";
-  name = "Google Gemini";
-  version = "1.0.0";
-  extensions = {
-    gemini: {
-      grounding: { enabled: true, dynamicThreshold: 0.3 },
-      multimodal: {
-        videoEnabled: true,
-        audioEnabled: true,
-        maxVideoDurationSec: 60
-      },
-      codeExecution: { enabled: true }
-    }
-  };
-  apiKey;
-  baseUrl;
-  constructor(config) {
-    this.apiKey = config.apiKey;
-    this.baseUrl = config.baseUrl || "https://generativelanguage.googleapis.com/v1beta";
-  }
-  supportsExtension(extension) {
-    return extension === "gemini";
-  }
-  async *stream(messages, options) {
-    const contents = messages.filter((m) => m.role !== "system").map((m) => ({
-      role: m.role === "assistant" ? "model" : "user",
-      parts: [
-        {
-          text: typeof m.content === "string" ? m.content : m.content.filter((c) => c.type === "text").map((c) => c.text).join("")
-        }
-      ]
-    }));
-    const body = {
-      contents,
-      generationConfig: {
-        maxOutputTokens: options.maxTokens,
-        temperature: options.temperature,
-        topP: options.topP
-      }
-    };
-    const systemMsg = messages.find((m) => m.role === "system");
-    if (systemMsg || options.system) {
-      body.systemInstruction = {
-        parts: [
-          {
-            text: options.system || (typeof systemMsg?.content === "string" ? systemMsg.content : "")
-          }
-        ]
-      };
-    }
-    if (options.extensions?.grounding?.enabled) {
-      body.tools = [
-        {
-          googleSearchRetrieval: {
-            dynamicRetrievalConfig: {
-              mode: "MODE_DYNAMIC",
-              dynamicThreshold: options.extensions.grounding.dynamicThreshold
-            }
-          }
-        }
-      ];
-    }
-    if (options.extensions?.codeExecution?.enabled) {
-      body.tools = [
-        ...body.tools || [],
-        { codeExecution: {} }
-      ];
-    }
-    if (options.extensions?.safetySettings) {
-      body.safetySettings = options.extensions.safetySettings;
-    }
-    const url = `${this.baseUrl}/models/${options.model}:streamGenerateContent?key=${this.apiKey}&alt=sse`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      yield {
-        type: "error",
-        error: {
-          type: "api_error",
-          message: `Gemini API error: ${response.status} ${response.statusText}`
-        }
-      };
-      return;
-    }
-    yield {
-      type: "message_start",
-      message: {
-        id: `msg_${Date.now()}`,
-        model: options.model,
-        role: "assistant"
-      }
-    };
-    const reader = response.body?.getReader();
-    if (!reader) return;
-    const decoder = new TextDecoder();
-    let buffer = "";
-    const blockIndex = 0;
-    let blockStarted = false;
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (line.startsWith("data: ")) {
-          try {
-            const parsed = JSON.parse(line.slice(6));
-            const text = parsed.candidates?.[0]?.content?.parts?.[0]?.text;
-            if (text && !blockStarted) {
-              blockStarted = true;
-              yield {
-                type: "content_block_start",
-                index: blockIndex,
-                contentBlock: { type: "text", text: "" }
-              };
-            }
-            if (text) {
-              yield {
-                type: "content_block_delta",
-                index: blockIndex,
-                delta: { type: "text_delta", text }
-              };
-            }
-          } catch {
-          }
-        }
-      }
-    }
-    if (blockStarted) {
-      yield { type: "content_block_stop", index: blockIndex };
-    }
-    yield { type: "message_stop" };
-  }
-  async complete(messages, options) {
-    const contents = messages.filter((m) => m.role !== "system").map((m) => ({
-      role: m.role === "assistant" ? "model" : "user",
-      parts: [
-        {
-          text: typeof m.content === "string" ? m.content : m.content.filter((c) => c.type === "text").map((c) => c.text).join("")
-        }
-      ]
-    }));
-    const body = {
-      contents,
-      generationConfig: {
-        maxOutputTokens: options.maxTokens,
-        temperature: options.temperature
-      }
-    };
-    const url = `${this.baseUrl}/models/${options.model}:generateContent?key=${this.apiKey}`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      throw new Error(
-        `Gemini API error: ${response.status} ${response.statusText}`
-      );
-    }
-    const data = await response.json();
-    const candidate = data.candidates?.[0];
-    const text = candidate?.content?.parts?.[0]?.text ?? "";
-    return {
-      content: [{ type: "text", text }],
-      usage: {
-        inputTokens: data.usageMetadata?.promptTokenCount ?? 0,
-        outputTokens: data.usageMetadata?.candidatesTokenCount ?? 0
-      },
-      stopReason: candidate?.finishReason ?? "STOP"
-    };
-  }
-  async validateConnection() {
-    try {
-      const response = await fetch(`${this.baseUrl}/models?key=${this.apiKey}`);
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-  async listModels() {
-    return [
-      "gemini-2.0-flash-exp",
-      "gemini-1.5-pro",
-      "gemini-1.5-flash",
-      "gemini-1.5-flash-8b",
-      "gemini-1.0-pro"
-    ];
-  }
-}
 function createProvider(id, config) {
   switch (id) {
-    case "claude":
+    case "anthropic":
       return new ClaudeAdapter(config);
-    case "gpt":
+    case "openai":
+    case "qwen":
+    case "ollama":
       return new GPTAdapter(config);
-    case "gemini":
-      return new GeminiAdapter(config);
+    case "cerebras":
+      return new GPTAdapter({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl || "https://api.cerebras.ai/v1"
+      });
+    case "deepinfra":
+      return new GPTAdapter({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl || "https://api.deepinfra.com/v1/openai"
+      });
+    case "openrouter":
+      return new GPTAdapter({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl || "https://openrouter.ai/api"
+      });
     default:
-      throw new Error(`Unknown provider: ${id}`);
-  }
-}
-class ProviderRegistry {
-  providers = /* @__PURE__ */ new Map();
-  register(adapter) {
-    this.providers.set(adapter.id, adapter);
-  }
-  get(id) {
-    return this.providers.get(id);
-  }
-  list() {
-    return Array.from(this.providers.values());
-  }
-  has(id) {
-    return this.providers.has(id);
-  }
-  /**
-   * Find providers that support a specific extension
-   */
-  findByExtension(extension) {
-    return this.list().filter((p) => p.supportsExtension(extension));
+      throw new Error(`No adapter for provider: ${id}`);
   }
 }
-const providerRegistry = new ProviderRegistry();
 export {
   ClaudeAdapter,
   GPTAdapter,
-  GeminiAdapter,
-  ProviderRegistry,
-  createProvider,
-  providerRegistry
+  createProvider
 };

package/dist/src/core/models/complexity-scorer.js

@@ -0,0 +1,154 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+const HIGH_COMPLEXITY_KEYWORDS = [
+  /\barchitect/i,
+  /\brefactor\b/i,
+  /\bredesign/i,
+  /\bmigrat/i,
+  /\bsecurity\b/i,
+  /\bvulnerabilit/i,
+  /\bconcurrency/i,
+  /\brace\s+condition/i,
+  /\bdistributed/i,
+  /\bconsensus/i,
+  /\btrade-?offs?\b/i,
+  /\bbackward.?compat/i,
+  /\bbreaking\s+change/i,
+  /\bperformance\s+(?:optimi|critical|bottleneck)/i,
+  /\bscalability/i,
+  /\bcrypto/i,
+  /\bencrypt/i,
+  /\bauth(?:entication|orization)\b/i,
+  /\bOWASP/i
+];
+const LOW_COMPLEXITY_KEYWORDS = [
+  /\bfix\s+typo/i,
+  /\brename\b/i,
+  /\bformat(?:ting)?\s+(?:the\s+)?(?:code|file|project|source)/i,
+  /\bprettier/i,
+  /\blint\s*(?:fix|error|warning)/i,
+  /\bupdate\s+(?:version|dep)/i,
+  /\badd\s+comment/i,
+  /\bremove\s+unused/i,
+  /\bimport\s+(?:sort|order)/i,
+  /\bconsole\.log/i,
+  /\btodo\b/i,
+  /\bcleanup\b/i
+];
+const MEDIUM_COMPLEXITY_KEYWORDS = [
+  /\bwrite\b/i,
+  /\bimplement/i,
+  /\bcreate\b/i,
+  /\bbuild\b/i,
+  /\bparse/i,
+  /\bhandle\b/i,
+  /\bvalidat/i,
+  /\btransform/i,
+  /\bconvert/i,
+  /\bgenerat/i,
+  /\bintegrat/i,
+  /\boptimiz/i
+];
+const REASONING_INDICATORS = [
+  /\bstep\s*(?:by|1|2|3)/i,
+  /\bfirst.*then.*finally/i,
+  /\bcompare\s+(?:and|options|approaches)/i,
+  /\banalyze/i,
+  /\bevaluate/i,
+  /\bdiagnos/i,
+  /\bdebug.*(?:complex|intermittent|flaky)/i,
+  /\broot\s+cause/i,
+  /\bsystem\s*design/i
+];
+const LOW_THRESHOLD = 0.25;
+const HIGH_THRESHOLD = 0.6;
+const SHORT_PROMPT = 200;
+const MEDIUM_PROMPT = 800;
+const LONG_PROMPT = 2e3;
+function scoreComplexity(task, context) {
+  const signals = [];
+  let score = 0;
+  const highHits = HIGH_COMPLEXITY_KEYWORDS.filter((re) => re.test(task));
+  if (highHits.length >= 5) {
+    score += 0.6;
+    signals.push(`${highHits.length} high-complexity keywords`);
+  } else if (highHits.length >= 3) {
+    score += 0.5;
+    signals.push(`${highHits.length} high-complexity keywords`);
+  } else if (highHits.length >= 1) {
+    score += 0.2 * Math.min(highHits.length, 2);
+    signals.push(`${highHits.length} high-complexity keyword(s)`);
+  }
+  const lowHits = LOW_COMPLEXITY_KEYWORDS.filter((re) => re.test(task));
+  if (lowHits.length >= 2) {
+    score -= 0.25;
+    signals.push(`${lowHits.length} low-complexity keywords`);
+  } else if (lowHits.length === 1) {
+    score -= 0.15;
+    signals.push("1 low-complexity keyword");
+  }
+  const medHits = MEDIUM_COMPLEXITY_KEYWORDS.filter((re) => re.test(task));
+  if (medHits.length >= 2) {
+    score += 0.3;
+    signals.push(`${medHits.length} medium-complexity keywords`);
+  } else if (medHits.length === 1) {
+    score += 0.15;
+    signals.push("1 medium-complexity keyword");
+  }
+  const hasSubstance = highHits.length > 0 || medHits.length > 0;
+  const len = task.length;
+  if (len > LONG_PROMPT && hasSubstance) {
+    score += 0.2;
+    signals.push(`long prompt (${len} chars)`);
+  } else if (len > MEDIUM_PROMPT && hasSubstance) {
+    score += 0.1;
+    signals.push(`medium prompt (${len} chars)`);
+  } else if (len < SHORT_PROMPT) {
+    score -= 0.03;
+  }
+  const reasoningHits = REASONING_INDICATORS.filter((re) => re.test(task));
+  if (reasoningHits.length >= 2) {
+    score += 0.25;
+    signals.push(`${reasoningHits.length} reasoning indicators`);
+  } else if (reasoningHits.length === 1) {
+    score += 0.15;
+    signals.push("1 reasoning indicator");
+  }
+  if (context) {
+    const files = context["files"];
+    if (Array.isArray(files)) {
+      if (files.length >= 10) {
+        score += 0.15;
+        signals.push(`${files.length} files in context`);
+      } else if (files.length >= 4) {
+        score += 0.08;
+        signals.push(`${files.length} files in context`);
+      }
+    }
+    const codeSize = context["codeSize"];
+    if (typeof codeSize === "number" && codeSize > 5e3) {
+      score += 0.1;
+      signals.push(`large code context (${codeSize} chars)`);
+    }
+  }
+  const questionMarks = (task.match(/\?/g) || []).length;
+  if (questionMarks >= 3) {
+    score += 0.1;
+    signals.push(`${questionMarks} questions`);
+  }
+  score = Math.max(0, Math.min(1, score));
+  let tier;
+  if (score < LOW_THRESHOLD) {
+    tier = "low";
+  } else if (score >= HIGH_THRESHOLD) {
+    tier = "high";
+  } else {
+    tier = "medium";
+  }
+  return { score: Math.round(score * 100) / 100, tier, signals };
+}
+export {
+  scoreComplexity
+};