@stackmemoryai/stackmemory 1.0.1 → 1.2.0

package/dist/src/core/models/model-router.js

@@ -10,6 +10,40 @@ import {
   ModelRouterConfigSchema,
   parseConfigSafe
 } from "../../hooks/schemas.js";
+import { isFeatureEnabled } from "../config/feature-flags.js";
+import { scoreComplexity } from "./complexity-scorer.js";
+import {
+  detectSensitiveContent,
+  isApprovedProvider
+} from "./sensitive-guard.js";
+const MODEL_TOKEN_LIMITS = {
+  // Claude 4.x / 4.5 / 4.6
+  "claude-opus-4-6": 2e5,
+  "claude-sonnet-4-5-20250929": 2e5,
+  "claude-haiku-4-5-20251001": 2e5,
+  "claude-sonnet-4-20250514": 2e5,
+  // Claude 3.x
+  "claude-3-5-sonnet-20241022": 2e5,
+  "claude-3-5-haiku-20241022": 2e5,
+  "claude-3-opus-20240229": 2e5,
+  // OpenAI
+  "gpt-4o": 128e3,
+  "gpt-4-turbo": 128e3,
+  "gpt-4": 8192,
+  o1: 2e5,
+  "o3-mini": 2e5,
+  // Qwen
+  "qwen3-max-2025-01-23": 128e3,
+  // Cerebras
+  "llama-4-scout-17b-16e-instruct": 131072,
+  // DeepInfra
+  "THUDM/glm-4-9b-chat": 128e3
+};
+const DEFAULT_MODEL_TOKEN_LIMIT = 2e5;
+function getModelTokenLimit(model) {
+  if (!model) return DEFAULT_MODEL_TOKEN_LIMIT;
+  return MODEL_TOKEN_LIMITS[model] ?? DEFAULT_MODEL_TOKEN_LIMIT;
+}
 const CONFIG_PATH = join(homedir(), ".stackmemory", "model-router.json");
 const DEFAULT_CONFIG = {
   enabled: false,
@@ -40,6 +74,29 @@ const DEFAULT_CONFIG = {
         enable_thinking: true,
         thinking_budget: 1e4
       }
+    },
+    cerebras: {
+      provider: "cerebras",
+      model: "llama-4-scout-17b-16e-instruct",
+      baseUrl: "https://api.cerebras.ai/v1",
+      apiKeyEnv: "CEREBRAS_API_KEY"
+    },
+    deepinfra: {
+      provider: "deepinfra",
+      model: "THUDM/glm-4-9b-chat",
+      baseUrl: "https://api.deepinfra.com/v1/openai",
+      apiKeyEnv: "DEEPINFRA_API_KEY"
+    },
+    openrouter: {
+      provider: "openrouter",
+      model: "meta-llama/llama-4-scout",
+      baseUrl: "https://openrouter.ai/api",
+      apiKeyEnv: "OPENROUTER_API_KEY"
+    },
+    "anthropic-batch": {
+      provider: "anthropic-batch",
+      model: "claude-sonnet-4-5-20250929",
+      apiKeyEnv: "ANTHROPIC_API_KEY"
     }
   },
   thinkingMode: {
@@ -49,28 +106,43 @@ const DEFAULT_CONFIG = {
     topP: 0.95
   }
 };
+let _configCache = null;
+const CONFIG_CACHE_TTL_MS = 5e3;
 function loadModelRouterConfig() {
+  const now = Date.now();
+  if (_configCache && now < _configCache.expiresAt) {
+    return _configCache.config;
+  }
+  let config;
   try {
     if (existsSync(CONFIG_PATH)) {
       const data = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
-      return parseConfigSafe(
+      config = parseConfigSafe(
         ModelRouterConfigSchema,
         { ...DEFAULT_CONFIG, ...data },
         DEFAULT_CONFIG,
         "model-router"
       );
+    } else {
+      config = { ...DEFAULT_CONFIG };
     }
   } catch {
+    config = { ...DEFAULT_CONFIG };
   }
-  return { ...DEFAULT_CONFIG };
+  _configCache = { config, expiresAt: now + CONFIG_CACHE_TTL_MS };
+  return config;
 }
 function saveModelRouterConfig(config) {
   try {
     ensureSecureDir(join(homedir(), ".stackmemory"));
     writeFileSecure(CONFIG_PATH, JSON.stringify(config, null, 2));
+    _configCache = null;
   } catch {
   }
 }
+function invalidateConfigCache() {
+  _configCache = null;
+}
 function getModelForTask(taskType) {
   const config = loadModelRouterConfig();
   if (!config.enabled) {
@@ -124,6 +196,156 @@ function requiresDeepThinking(input) {
   ];
   return thinkPatterns.some((pattern) => pattern.test(input));
 }
+const OPTIMAL_ROUTING = {
+  linting: {
+    provider: "deepinfra",
+    model: "THUDM/glm-4-9b-chat",
+    apiKeyEnv: "DEEPINFRA_API_KEY",
+    baseUrl: "https://api.deepinfra.com/v1/openai"
+  },
+  context: {
+    provider: "deepinfra",
+    model: "THUDM/glm-4-9b-chat",
+    apiKeyEnv: "DEEPINFRA_API_KEY",
+    baseUrl: "https://api.deepinfra.com/v1/openai"
+  },
+  code: {
+    provider: "cerebras",
+    model: "llama-4-scout-17b-16e-instruct",
+    apiKeyEnv: "CEREBRAS_API_KEY",
+    baseUrl: "https://api.cerebras.ai/v1"
+  },
+  testing: {
+    provider: "cerebras",
+    model: "llama-4-scout-17b-16e-instruct",
+    apiKeyEnv: "CEREBRAS_API_KEY",
+    baseUrl: "https://api.cerebras.ai/v1"
+  },
+  review: {
+    provider: "anthropic",
+    model: "claude-sonnet-4-5-20250929",
+    apiKeyEnv: "ANTHROPIC_API_KEY"
+  },
+  plan: {
+    provider: "anthropic",
+    model: "claude-sonnet-4-5-20250929",
+    apiKeyEnv: "ANTHROPIC_API_KEY"
+  },
+  think: {
+    provider: "anthropic",
+    model: "claude-sonnet-4-5-20250929",
+    apiKeyEnv: "ANTHROPIC_API_KEY"
+  }
+};
+const FALLBACK_CHAIN = ["deepinfra", "cerebras", "anthropic"];
+const CHEAP_PROVIDERS = [
+  {
+    provider: "openrouter",
+    model: "meta-llama/llama-4-scout",
+    apiKeyEnv: "OPENROUTER_API_KEY",
+    baseUrl: "https://openrouter.ai/api"
+  },
+  {
+    provider: "deepinfra",
+    model: "THUDM/glm-4-9b-chat",
+    apiKeyEnv: "DEEPINFRA_API_KEY",
+    baseUrl: "https://api.deepinfra.com/v1/openai"
+  },
+  {
+    provider: "cerebras",
+    model: "llama-4-scout-17b-16e-instruct",
+    apiKeyEnv: "CEREBRAS_API_KEY",
+    baseUrl: "https://api.cerebras.ai/v1"
+  }
+];
+function getOptimalProvider(taskType, preference, complexityInput) {
+  const defaultResult = {
+    provider: "anthropic",
+    model: "claude-sonnet-4-5-20250929",
+    apiKeyEnv: "ANTHROPIC_API_KEY"
+  };
+  if (!isFeatureEnabled("multiProvider")) {
+    return defaultResult;
+  }
+  if (complexityInput) {
+    const sensitiveCheck = detectSensitiveContent(
+      complexityInput.task,
+      complexityInput.context
+    );
+    if (sensitiveCheck.sensitive) {
+      return defaultResult;
+    }
+  }
+  if (preference) {
+    if (!isApprovedProvider(preference) && complexityInput) {
+      const check = detectSensitiveContent(
+        complexityInput.task,
+        complexityInput.context
+      );
+      if (check.sensitive) {
+        return defaultResult;
+      }
+    }
+    const config = loadModelRouterConfig();
+    const providerConfig = config.providers[preference];
+    if (providerConfig && process.env[providerConfig.apiKeyEnv]) {
+      return {
+        provider: preference,
+        model: providerConfig.model,
+        baseUrl: providerConfig.baseUrl,
+        apiKeyEnv: providerConfig.apiKeyEnv
+      };
+    }
+  }
+  if (complexityInput) {
+    const complexity = scoreComplexity(
+      complexityInput.task,
+      complexityInput.context
+    );
+    if (complexity.tier === "low") {
+      const cheap = findAvailableCheapProvider();
+      if (cheap) return cheap;
+    }
+    if (complexity.tier === "high") {
+      return defaultResult;
+    }
+  }
+  const route = OPTIMAL_ROUTING[taskType];
+  if (route && process.env[route.apiKeyEnv]) {
+    return { ...route };
+  }
+  const fallbackConfig = loadModelRouterConfig();
+  for (const provider of FALLBACK_CHAIN) {
+    const providerConfig = fallbackConfig.providers[provider];
+    if (providerConfig && process.env[providerConfig.apiKeyEnv]) {
+      return {
+        provider,
+        model: providerConfig.model,
+        baseUrl: providerConfig.baseUrl,
+        apiKeyEnv: providerConfig.apiKeyEnv
+      };
+    }
+  }
+  return defaultResult;
+}
+function findAvailableCheapProvider() {
+  for (const p of CHEAP_PROVIDERS) {
+    if (process.env[p.apiKeyEnv]) {
+      return {
+        provider: p.provider,
+        model: p.model,
+        apiKeyEnv: p.apiKeyEnv,
+        baseUrl: p.baseUrl
+      };
+    }
+  }
+  return null;
+}
+function getComplexityRoutedProvider(taskType, task, context) {
+  const complexity = scoreComplexity(task, context);
+  const provider = getOptimalProvider(taskType, void 0, { task, context });
+  return { ...provider, complexity: complexity.tier };
+}
 class ModelRouter {
   config;
   currentProvider;
@@ -196,28 +418,6 @@ class ModelRouter {
     const apiKey = process.env[fallbackProvider.apiKeyEnv];
     return !!apiKey;
   }
-  /**
-   * Check if error should trigger fallback
-   */
-  shouldFallback(error) {
-    if (!this.isFallbackEnabled()) return false;
-    if (this.inFallbackMode) return false;
-    const fallback = this.config.fallback;
-    if (fallback.onRateLimit && error.status === 429) {
-      return true;
-    }
-    if (fallback.onError && error.status && error.status >= 500) {
-      return true;
-    }
-    if (fallback.onTimeout) {
-      const isTimeout = error.code === "ETIMEDOUT" || error.code === "ESOCKETTIMEDOUT" || error.message?.toLowerCase().includes("timeout");
-      if (isTimeout) return true;
-    }
-    if (error.message?.toLowerCase().includes("overloaded")) {
-      return true;
-    }
-    return false;
-  }
   /**
    * Activate fallback mode
    */
@@ -278,16 +478,6 @@ function getModelRouter() {
   }
   return routerInstance;
 }
-function getPlanModeEnv() {
-  const router = getModelRouter();
-  const result = router.route("plan");
-  return result.env;
-}
-function getThinkingModeEnv() {
-  const router = getModelRouter();
-  const result = router.route("think");
-  return result.env;
-}
 function isFallbackAvailable() {
   const router = getModelRouter();
   return router.isFallbackEnabled();
@@ -322,13 +512,17 @@ function resetFallback() {
   router.reset();
 }
 export {
+  DEFAULT_MODEL_TOKEN_LIMIT,
+  MODEL_TOKEN_LIMITS,
   ModelRouter,
   buildModelEnv,
+  getComplexityRoutedProvider,
   getFallbackStatus,
   getModelForTask,
   getModelRouter,
-  getPlanModeEnv,
-  getThinkingModeEnv,
+  getModelTokenLimit,
+  getOptimalProvider,
+  invalidateConfigCache,
   isFallbackAvailable,
   isPlanningContext,
   loadModelRouterConfig,

package/dist/src/core/models/provider-pricing.js

@@ -0,0 +1,63 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+const MODEL_PRICING = {
+  // Anthropic (direct API)
+  "anthropic/claude-sonnet-4-5-20250929": {
+    inputPer1M: 3,
+    outputPer1M: 15,
+    source: "anthropic.com"
+  },
+  "anthropic/claude-sonnet-4-20250514": {
+    inputPer1M: 3,
+    outputPer1M: 15,
+    source: "anthropic.com"
+  },
+  "anthropic/claude-haiku-4-5-20251001": {
+    inputPer1M: 0.8,
+    outputPer1M: 4,
+    source: "anthropic.com"
+  },
+  // OpenAI (direct API)
+  "openai/gpt-4o": {
+    inputPer1M: 2.5,
+    outputPer1M: 10,
+    source: "openai.com"
+  },
+  // OpenRouter (aggregated)
+  "openrouter/meta-llama/llama-4-scout": {
+    inputPer1M: 0.08,
+    outputPer1M: 0.3,
+    source: "openrouter.ai/api/v1/models"
+  },
+  // Cerebras (free tier / inference)
+  "cerebras/llama-4-scout-17b-16e-instruct": {
+    inputPer1M: 0.1,
+    outputPer1M: 0.1,
+    source: "cerebras.ai"
+  },
+  // DeepInfra
+  "deepinfra/THUDM/glm-4-9b-chat": {
+    inputPer1M: 0.065,
+    outputPer1M: 0.065,
+    source: "deepinfra.com"
+  }
+};
+function calculateCost(provider, model, inputTokens, outputTokens) {
+  const key = `${provider}/${model}`;
+  const pricing = MODEL_PRICING[key];
+  if (!pricing) return null;
+  const inputCost = inputTokens / 1e6 * pricing.inputPer1M;
+  const outputCost = outputTokens / 1e6 * pricing.outputPer1M;
+  return { inputCost, outputCost, totalCost: inputCost + outputCost };
+}
+function formatCost(usd) {
+  if (usd < 0.01) return `$${usd.toFixed(6)}`;
+  return `$${usd.toFixed(4)}`;
+}
+export {
+  MODEL_PRICING,
+  calculateCost,
+  formatCost
+};

package/dist/src/core/models/sensitive-guard.js

@@ -0,0 +1,112 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+const SENSITIVE_PATTERNS = [
+  // API keys — common prefixes
+  { pattern: /\bsk-[a-zA-Z0-9]{20,}/, label: "API key (sk-)" },
+  { pattern: /\bsk-ant-[a-zA-Z0-9-]{20,}/, label: "Anthropic key" },
+  { pattern: /\bAKIA[A-Z0-9]{12,}/, label: "AWS access key" },
+  { pattern: /\bghp_[a-zA-Z0-9]{30,}/, label: "GitHub PAT" },
+  { pattern: /\bgho_[a-zA-Z0-9]{30,}/, label: "GitHub OAuth" },
+  { pattern: /\bghs_[a-zA-Z0-9]{30,}/, label: "GitHub App" },
+  { pattern: /\bglpat-[a-zA-Z0-9_-]{20,}/, label: "GitLab PAT" },
+  { pattern: /\bnpm_[a-zA-Z0-9]{30,}/, label: "npm token" },
+  { pattern: /\bxox[bpsar]-[a-zA-Z0-9-]{10,}/, label: "Slack token" },
+  { pattern: /\blin_api_[a-zA-Z0-9]{20,}/, label: "Linear API key" },
+  { pattern: /\blin_oauth_[a-zA-Z0-9]{20,}/, label: "Linear OAuth" },
+  { pattern: /\bSG\.[a-zA-Z0-9_-]{20,}/, label: "SendGrid key" },
+  { pattern: /\brk_live_[a-zA-Z0-9]{20,}/, label: "Stripe key" },
+  { pattern: /\bsk_(?:live|test)_[a-zA-Z0-9]{20,}/, label: "Stripe secret" },
+  { pattern: /\bwhsec_[a-zA-Z0-9]{20,}/, label: "Webhook secret" },
+  // Private keys and certificates
+  {
+    pattern: /-----BEGIN\s+(?:RSA\s+)?PRIVATE\s+KEY-----/,
+    label: "Private key (PEM)"
+  },
+  { pattern: /-----BEGIN\s+CERTIFICATE-----/, label: "Certificate (PEM)" },
+  {
+    pattern: /-----BEGIN\s+(?:EC\s+)?PRIVATE\s+KEY-----/,
+    label: "EC private key"
+  },
+  // JWT tokens (header.payload.signature format)
+  {
+    pattern: /\beyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}/,
+    label: "JWT token"
+  },
+  { pattern: /\bBearer\s+eyJ[a-zA-Z0-9_-]{10,}/, label: "Bearer JWT" },
+  // Connection strings with credentials
+  {
+    pattern: /(?:mysql|postgres|postgresql|mongodb|redis):\/\/[^:]+:[^@]+@/,
+    label: "DB connection string"
+  },
+  // Generic high-entropy secrets (base64 blocks in config-like context)
+  {
+    pattern: /(?:password|secret|token|api[_-]?key|auth[_-]?token)\s*[:=]\s*["'][^"']{8,}["']/i,
+    label: "Credential assignment"
+  },
+  {
+    pattern: /(?:PASSWORD|SECRET|TOKEN|API_KEY|AUTH_TOKEN)\s*=\s*\S{8,}/,
+    label: "Env var credential"
+  }
+];
+const APPROVED_PROVIDERS = /* @__PURE__ */ new Set(["anthropic", "anthropic-batch"]);
+function checkString(text) {
+  const matches = [];
+  for (const { pattern, label } of SENSITIVE_PATTERNS) {
+    if (pattern.test(text)) {
+      matches.push(label);
+    }
+  }
+  return { sensitive: matches.length > 0, matches };
+}
+function detectSensitiveContent(task, context) {
+  const allMatches = [];
+  const taskResult = checkString(task);
+  allMatches.push(...taskResult.matches);
+  if (context) {
+    for (const value of Object.values(context)) {
+      if (typeof value === "string") {
+        const r = checkString(value);
+        allMatches.push(...r.matches);
+      } else if (Array.isArray(value)) {
+        for (const item of value) {
+          if (typeof item === "string") {
+            const r = checkString(item);
+            allMatches.push(...r.matches);
+          }
+        }
+      } else if (value && typeof value === "object") {
+        for (const nested of Object.values(value)) {
+          if (typeof nested === "string") {
+            const r = checkString(nested);
+            allMatches.push(...r.matches);
+          }
+        }
+      }
+    }
+  }
+  const unique = [...new Set(allMatches)];
+  return { sensitive: unique.length > 0, matches: unique };
+}
+function isApprovedProvider(provider) {
+  return APPROVED_PROVIDERS.has(provider);
+}
+function shouldBlockProvider(provider, task, context) {
+  if (isApprovedProvider(provider)) {
+    return { blocked: false };
+  }
+  const check = detectSensitiveContent(task, context);
+  if (!check.sensitive) {
+    return { blocked: false };
+  }
+  return {
+    blocked: true,
+    reason: `Sensitive content detected (${check.matches.join(", ")}). Blocked routing to ${provider}; using approved provider instead.`
+  };
+}
+export {
+  detectSensitiveContent,
+  isApprovedProvider,
+  shouldBlockProvider
+};

package/dist/src/core/monitoring/feedback-loops.js

@@ -0,0 +1,88 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { EventEmitter } from "events";
+const DEFAULT_CONFIG = {
+  contextPressure: { enabled: true, cooldownSec: 60 },
+  editRecovery: { enabled: true, cooldownSec: 0 },
+  retrievalQuality: { enabled: true, cooldownSec: 300 },
+  traceErrorChain: { enabled: true, cooldownSec: 30 },
+  harnessRegression: { enabled: true, cooldownSec: 0 },
+  sessionDrift: { enabled: true, cooldownSec: 120 }
+};
+class FeedbackLoopEngine extends EventEmitter {
+  config;
+  lastFired = /* @__PURE__ */ new Map();
+  history = [];
+  maxHistory = 200;
+  constructor(config = {}) {
+    super();
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /**
+   * Fire a loop if enabled and not in cooldown.
+   * Returns the LoopEvent if fired, null if skipped.
+   */
+  fire(loopName, trigger, data, action, outcome = "success") {
+    const cfg = this.config[loopName];
+    if (!cfg?.enabled) return null;
+    const now = Date.now();
+    const lastTime = this.lastFired.get(loopName) || 0;
+    if (now - lastTime < cfg.cooldownSec * 1e3) return null;
+    const event = {
+      loop: loopName,
+      trigger,
+      timestamp: now,
+      data,
+      action,
+      outcome
+    };
+    this.lastFired.set(loopName, now);
+    this.history.push(event);
+    if (this.history.length > this.maxHistory) {
+      this.history = this.history.slice(-this.maxHistory);
+    }
+    this.emit("loop", event);
+    this.emit(`loop:${loopName}`, event);
+    return event;
+  }
+  /** Get recent loop events, optionally filtered by loop name. */
+  getHistory(loopName, limit = 50) {
+    const filtered = loopName ? this.history.filter((e) => e.loop === loopName) : this.history;
+    return filtered.slice(-limit);
+  }
+  /** Get summary stats per loop. */
+  getStats() {
+    const stats = {};
+    for (const event of this.history) {
+      if (!stats[event.loop]) {
+        stats[event.loop] = {
+          fires: 0,
+          successes: 0,
+          errors: 0,
+          lastFired: null
+        };
+      }
+      stats[event.loop].fires++;
+      if (event.outcome === "success") stats[event.loop].successes++;
+      if (event.outcome === "error") stats[event.loop].errors++;
+      stats[event.loop].lastFired = event.timestamp;
+    }
+    return stats;
+  }
+  /** Update config at runtime. */
+  updateConfig(partial) {
+    this.config = { ...this.config, ...partial };
+  }
+  /** Get current config. */
+  getConfig() {
+    return { ...this.config };
+  }
+}
+const feedbackLoops = new FeedbackLoopEngine();
+export {
+  DEFAULT_CONFIG,
+  FeedbackLoopEngine,
+  feedbackLoops
+};

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({