@stackmemoryai/stackmemory 1.12.0 → 1.14.0

package/dist/src/core/retrieval/unified-context-assembler.js

@@ -6,6 +6,7 @@ import {
   createPrivacyFilter
 } from "./privacy-filter.js";
 import { logger } from "../monitoring/logger.js";
+import { estimateTokens } from "../cache/token-estimator.js";
 const DEFAULT_UNIFIED_CONTEXT_CONFIG = {
   totalTokenBudget: 8e3,
   userKnowledgeBudget: 0.2,
@@ -16,10 +17,6 @@ const DEFAULT_UNIFIED_CONTEXT_CONFIG = {
   // 10%
   privacyMode: "standard"
 };
-function estimateTokens(content) {
-  if (!content) return 0;
-  return Math.ceil(content.length / 4);
-}
 function truncateToTokenBudget(content, tokenBudget) {
   if (!content) return "";
   const estimatedTokens = estimateTokens(content);
@@ -36,12 +33,10 @@ function truncateToTokenBudget(content, tokenBudget) {
 }
 class UnifiedContextAssembler {
   stackMemoryRetrieval;
-  diffMemHooks;
   config;
   privacyFilter;
-  constructor(stackMemoryRetrieval, diffMemHooks, config = {}) {
+  constructor(stackMemoryRetrieval, config = {}) {
     this.stackMemoryRetrieval = stackMemoryRetrieval;
-    this.diffMemHooks = diffMemHooks;
     this.config = { ...DEFAULT_UNIFIED_CONTEXT_CONFIG, ...config };
     this.privacyFilter = createPrivacyFilter(this.config.privacyMode);
     const totalAllocation = this.config.userKnowledgeBudget + this.config.taskContextBudget + this.config.systemContextBudget;
@@ -69,11 +64,10 @@ class UnifiedContextAssembler {
     const systemContextBudget = Math.floor(
       this.config.totalTokenBudget * this.config.systemContextBudget
     );
-    const {
-      content: userKnowledge,
-      memories: diffMemMemories,
-      available: diffMemAvailable
-    } = await this.gatherUserKnowledge(query, userKnowledgeBudget);
+    const { content: userKnowledge } = await this.gatherUserKnowledge(
+      query,
+      userKnowledgeBudget
+    );
     const userKnowledgeFiltered = this.privacyFilter.filter(userKnowledge);
     totalPrivacyFiltered += userKnowledgeFiltered.redactedCount;
     const filteredUserKnowledge = truncateToTokenBudget(
@@ -110,8 +104,6 @@ class UnifiedContextAssembler {
       budget: this.config.totalTokenBudget
     };
     const metadata = {
-      diffMemAvailable,
-      diffMemMemories,
       stackMemoryFrames: frameCount,
       privacyFiltered: totalPrivacyFiltered
     };
@@ -131,53 +123,10 @@ class UnifiedContextAssembler {
     };
   }
   /**
-   * Gather user knowledge from DiffMem
-   */
-  async gatherUserKnowledge(query, tokenBudget) {
-    if (!this.diffMemHooks) {
-      return { content: "", memories: 0, available: false };
-    }
-    try {
-      const status = await this.diffMemHooks.getStatus();
-      if (!status.connected) {
-        logger.debug("DiffMem not connected");
-        return { content: "", memories: 0, available: false };
-      }
-      const memories = await this.diffMemHooks.getRelevantMemories(query, 10);
-      if (memories.length === 0) {
-        return { content: "", memories: 0, available: true };
-      }
-      const sections = ["## User Knowledge"];
-      const byCategory = /* @__PURE__ */ new Map();
-      for (const memory of memories) {
-        const existing = byCategory.get(memory.category) || [];
-        existing.push(memory);
-        byCategory.set(memory.category, existing);
-      }
-      for (const [category, categoryMemories] of byCategory) {
-        sections.push(`
-### ${this.formatCategory(category)}`);
-        for (const memory of categoryMemories) {
-          const confidence = memory.confidence >= 0.8 ? "(high confidence)" : memory.confidence >= 0.5 ? "" : "(tentative)";
-          sections.push(`- ${memory.content} ${confidence}`);
-        }
-      }
-      const content = sections.join("\n");
-      return {
-        content: truncateToTokenBudget(content, tokenBudget),
-        memories: memories.length,
-        available: true
-      };
-    } catch (error) {
-      logger.warn("Failed to gather user knowledge from DiffMem", { error });
-      return { content: "", memories: 0, available: false };
-    }
-  }
-  /**
-   * Format category name for display
+   * Gather user knowledge (stub — memory service removed in v1.14)
    */
-  formatCategory(category) {
-    return category.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  async gatherUserKnowledge(_query, _tokenBudget) {
+    return { content: "", memories: 0, available: false };
   }
   /**
    * Gather task context from StackMemory
@@ -258,12 +207,8 @@ class UnifiedContextAssembler {
     }
   }
 }
-function createUnifiedContextAssembler(stackMemoryRetrieval, diffMemHooks = null, config = {}) {
-  return new UnifiedContextAssembler(
-    stackMemoryRetrieval,
-    diffMemHooks,
-    config
-  );
+function createUnifiedContextAssembler(stackMemoryRetrieval, config = {}) {
+  return new UnifiedContextAssembler(stackMemoryRetrieval, config);
 }
 export {
   DEFAULT_UNIFIED_CONTEXT_CONFIG,

package/dist/src/core/skill-packs/types.js

@@ -37,6 +37,18 @@ const SkillPackExampleSchema = z.object({
   input: z.string().min(1),
   output: z.string().min(1)
 });
+const KnownLicenseSchema = z.enum([
+  "MIT",
+  "Apache-2.0",
+  "ISC",
+  "BSD-2-Clause",
+  "BSD-3-Clause",
+  "CC-BY-4.0",
+  "CC-BY-SA-4.0",
+  "CC0-1.0",
+  "UNLICENSED"
+]);
+const LicenseSchema = KnownLicenseSchema.or(z.string().min(1));
 const PackNameSchema = z.string().min(1).regex(
   /^[\w-]+\/[\w-]+$/,
   'name must be namespace/pack-name (e.g. "coding/typescript-react")'
@@ -46,7 +58,7 @@ const SkillPackManifestSchema = z.object({
   version: SemverSchema,
   description: z.string().min(1),
   author: z.string().min(1),
-  license: z.string().default("MIT"),
+  license: LicenseSchema.default("MIT"),
   runtime: SkillPackRuntimeSchema.optional(),
   ingestion: SkillPackIngestionSchema.optional(),
   ontology: SkillPackOntologySchema.optional(),
@@ -55,6 +67,7 @@ const SkillPackManifestSchema = z.object({
   instructions: z.string().optional()
 });
 export {
+  KnownLicenseSchema,
   SkillPackExampleSchema,
   SkillPackIngestionSchema,
   SkillPackManifestSchema,

package/dist/src/core/storage/cloud-sync-manager.js

@@ -0,0 +1,116 @@
+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";
+import { CloudSyncEngine } from "./cloud-sync.js";
+import { logger } from "../monitoring/logger.js";
+class CloudSyncManager extends EventEmitter {
+  engine;
+  config;
+  periodicTimer;
+  debounceTimer;
+  running = false;
+  constructor(db, config) {
+    super();
+    this.config = config;
+    this.engine = new CloudSyncEngine(db, config);
+  }
+  /**
+   * Start the sync manager (periodic sync if configured)
+   */
+  start() {
+    if (this.running) return;
+    this.running = true;
+    if (this.config.autoSync && this.config.syncIntervalMs > 0) {
+      this.periodicTimer = setInterval(() => {
+        this.performPush("periodic").catch(
+          (e) => logger.error("Periodic cloud sync failed", { error: String(e) })
+        );
+      }, this.config.syncIntervalMs);
+    }
+    logger.info("Cloud sync manager started", {
+      autoSync: this.config.autoSync,
+      intervalMs: this.config.syncIntervalMs
+    });
+  }
+  /**
+   * Stop the sync manager
+   */
+  stop() {
+    if (!this.running) return;
+    this.running = false;
+    if (this.periodicTimer) {
+      clearInterval(this.periodicTimer);
+      this.periodicTimer = void 0;
+    }
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = void 0;
+    }
+    logger.info("Cloud sync manager stopped");
+  }
+  /**
+   * Schedule a debounced push (used by frame lifecycle hooks)
+   */
+  scheduleDebouncedPush(trigger) {
+    if (!this.config.enabled || !this.running) return;
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = void 0;
+      this.performPush(trigger).catch(
+        (e) => logger.error("Debounced cloud sync push failed", {
+          error: String(e)
+        })
+      );
+    }, this.config.debounceMs);
+  }
+  /**
+   * Perform a push
+   */
+  async performPush(trigger, force = false) {
+    const result = await this.engine.push(force);
+    this.emit("push", { trigger, result });
+    return result;
+  }
+  /**
+   * Perform a pull
+   */
+  async performPull(trigger, tables) {
+    const result = await this.engine.pull(tables);
+    this.emit("pull", { trigger, result });
+    return result;
+  }
+  /**
+   * Get sync status
+   */
+  getStatus() {
+    return this.engine.status();
+  }
+  /**
+   * Check if manager is running
+   */
+  isRunning() {
+    return this.running;
+  }
+}
+const DEFAULT_SYNC_MANAGER_CONFIG = {
+  batchSize: 100,
+  conflictResolution: "newest_wins",
+  generationalPolicy: {
+    youngMaxAgeDays: 1,
+    matureMaxAgeDays: 7
+  },
+  timeoutMs: 3e4,
+  retryAttempts: 3,
+  retryBaseDelayMs: 1e3,
+  autoSync: false,
+  syncIntervalMs: 0,
+  debounceMs: 5e3
+};
+export {
+  CloudSyncManager,
+  DEFAULT_SYNC_MANAGER_CONFIG
+};