@stackmemoryai/stackmemory 1.10.5 → 1.14.0

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

@@ -0,0 +1,224 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import Database from "better-sqlite3";
+import * as path from "path";
+import * as fs from "fs";
+import { logger } from "../monitoring/logger.js";
+import { SkillPackManifestSchema } from "./types.js";
+const SCHEMA_VERSION = 1;
+const SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS schema_version (
+    version INTEGER PRIMARY KEY
+  );
+
+  CREATE TABLE IF NOT EXISTS packs (
+    name TEXT PRIMARY KEY,
+    version TEXT NOT NULL,
+    manifest TEXT NOT NULL,
+    instructions TEXT,
+    installed_at TEXT NOT NULL,
+    source TEXT
+  );
+
+  CREATE VIRTUAL TABLE IF NOT EXISTS packs_fts USING fts5(
+    name,
+    description,
+    instructions,
+    content='packs',
+    content_rowid='rowid'
+  );
+
+  CREATE TRIGGER IF NOT EXISTS packs_ai AFTER INSERT ON packs BEGIN
+    INSERT INTO packs_fts(rowid, name, description, instructions)
+    VALUES (new.rowid, new.name,
+            json_extract(new.manifest, '$.description'),
+            COALESCE(new.instructions, ''));
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS packs_ad AFTER DELETE ON packs BEGIN
+    INSERT INTO packs_fts(packs_fts, rowid, name, description, instructions)
+    VALUES ('delete', old.rowid, old.name,
+            json_extract(old.manifest, '$.description'),
+            COALESCE(old.instructions, ''));
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS packs_au AFTER UPDATE ON packs BEGIN
+    INSERT INTO packs_fts(packs_fts, rowid, name, description, instructions)
+    VALUES ('delete', old.rowid, old.name,
+            json_extract(old.manifest, '$.description'),
+            COALESCE(old.instructions, ''));
+    INSERT INTO packs_fts(rowid, name, description, instructions)
+    VALUES (new.rowid, new.name,
+            json_extract(new.manifest, '$.description'),
+            COALESCE(new.instructions, ''));
+  END;
+`;
+function getDefaultDbPath() {
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "/tmp";
+  return path.join(home, ".stackmemory", "skill-packs.db");
+}
+function rowToPack(row) {
+  const manifest = SkillPackManifestSchema.parse(
+    JSON.parse(row["manifest"])
+  );
+  const source = row["source"];
+  const metadata = {
+    installedAt: row["installed_at"],
+    ...source ? { source } : {}
+  };
+  return {
+    manifest,
+    instructions: row["instructions"] || void 0,
+    metadata
+  };
+}
+class SkillPackRegistry {
+  db;
+  dbPath;
+  constructor(dbPath) {
+    this.dbPath = dbPath || getDefaultDbPath();
+    const dir = path.dirname(this.dbPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(this.dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("busy_timeout = 5000");
+    this.initSchema();
+  }
+  initSchema() {
+    const versionRow = (() => {
+      try {
+        return this.db.prepare(
+          "SELECT name FROM sqlite_master WHERE type='table' AND name='schema_version'"
+        ).get();
+      } catch {
+        return void 0;
+      }
+    })();
+    if (!versionRow) {
+      this.db.exec(SCHEMA_SQL);
+      this.db.prepare("INSERT OR REPLACE INTO schema_version (version) VALUES (?)").run(SCHEMA_VERSION);
+      logger.debug("SkillPackRegistry: created schema v" + SCHEMA_VERSION);
+    }
+  }
+  // ============================================================
+  // CRUD
+  // ============================================================
+  /**
+   * Install or update a skill pack. Upserts by name.
+   */
+  install(pack) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const manifestJson = JSON.stringify(pack.manifest);
+    this.db.prepare(
+      `INSERT INTO packs (name, version, manifest, instructions, installed_at, source)
+         VALUES (?, ?, ?, ?, ?, ?)
+         ON CONFLICT(name) DO UPDATE SET
+           version = excluded.version,
+           manifest = excluded.manifest,
+           instructions = excluded.instructions,
+           installed_at = excluded.installed_at,
+           source = excluded.source`
+    ).run(
+      pack.manifest.name,
+      pack.manifest.version,
+      manifestJson,
+      pack.instructions ?? null,
+      pack.metadata?.installedAt ?? now,
+      pack.metadata?.source ?? null
+    );
+    logger.debug(
+      `SkillPackRegistry: installed ${pack.manifest.name}@${pack.manifest.version}`
+    );
+  }
+  /**
+   * Uninstall a pack by name.
+   */
+  uninstall(name) {
+    const result = this.db.prepare("DELETE FROM packs WHERE name = ?").run(name);
+    return result.changes > 0;
+  }
+  /**
+   * Get a single pack by name.
+   */
+  get(name) {
+    const row = this.db.prepare("SELECT * FROM packs WHERE name = ?").get(name);
+    return row ? rowToPack(row) : void 0;
+  }
+  /**
+   * List packs with optional filters.
+   */
+  list(query) {
+    const conditions = [];
+    const params = [];
+    if (query?.namespace) {
+      conditions.push("name LIKE ? || '/%'");
+      params.push(query.namespace);
+    }
+    if (query?.runtime) {
+      conditions.push("json_extract(manifest, '$.runtime.type') = ?");
+      params.push(query.runtime);
+    }
+    const where = conditions.length ? "WHERE " + conditions.join(" AND ") : "";
+    const sql = `SELECT * FROM packs ${where} ORDER BY name`;
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(rowToPack);
+  }
+  /**
+   * Find the pack that provides a given MCP tool name.
+   */
+  getByTool(toolName) {
+    const rows = this.db.prepare("SELECT * FROM packs").all();
+    for (const row of rows) {
+      const manifest = JSON.parse(
+        row["manifest"]
+      );
+      const tools = manifest.mcp?.tools ?? [];
+      if (tools.some((t) => t.name === toolName)) {
+        return rowToPack(row);
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Full-text search across pack name, description, and instructions.
+   */
+  search(query) {
+    const sanitized = query.replace(/[^\w\s/-]/g, "").split(/\s+/).filter(Boolean).map((t) => `"${t}"`).join(" ");
+    if (!sanitized) return [];
+    const rows = this.db.prepare(
+      `SELECT p.* FROM packs p
+         JOIN packs_fts f ON p.rowid = f.rowid
+         WHERE packs_fts MATCH ?
+         ORDER BY rank`
+    ).all(sanitized);
+    return rows.map(rowToPack);
+  }
+  // ============================================================
+  // LIFECYCLE
+  // ============================================================
+  close() {
+    this.db.close();
+  }
+}
+let registryInstance;
+function getSkillPackRegistry(dbPath) {
+  if (!registryInstance) {
+    registryInstance = new SkillPackRegistry(dbPath);
+  }
+  return registryInstance;
+}
+function resetSkillPackRegistry() {
+  if (registryInstance) {
+    registryInstance.close();
+    registryInstance = void 0;
+  }
+}
+export {
+  SkillPackRegistry,
+  getSkillPackRegistry,
+  resetSkillPackRegistry
+};

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

@@ -0,0 +1,79 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { z } from "zod";
+const SemverSchema = z.string().regex(
+  /^\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/,
+  "version must be valid semver (e.g. 1.0.0)"
+);
+const SkillPackRuntimeTypeSchema = z.enum([
+  "local",
+  "e2b",
+  "cua",
+  "modal"
+]);
+const SkillPackRuntimeSchema = z.object({
+  type: SkillPackRuntimeTypeSchema.default("local"),
+  template: z.string().optional()
+});
+const SkillPackIngestionSchema = z.object({
+  sources: z.array(z.string()).default([]),
+  scope: z.string().optional()
+});
+const SkillPackOntologySchema = z.object({
+  entities: z.array(z.string()).default([]),
+  relations: z.array(z.string()).default([])
+});
+const SkillPackMcpToolSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().min(1),
+  inputSchema: z.record(z.unknown()).optional()
+});
+const SkillPackMcpSchema = z.object({
+  tools: z.array(SkillPackMcpToolSchema).default([])
+});
+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")'
+);
+const SkillPackManifestSchema = z.object({
+  name: PackNameSchema,
+  version: SemverSchema,
+  description: z.string().min(1),
+  author: z.string().min(1),
+  license: LicenseSchema.default("MIT"),
+  runtime: SkillPackRuntimeSchema.optional(),
+  ingestion: SkillPackIngestionSchema.optional(),
+  ontology: SkillPackOntologySchema.optional(),
+  mcp: SkillPackMcpSchema.optional(),
+  examples: z.array(SkillPackExampleSchema).optional(),
+  instructions: z.string().optional()
+});
+export {
+  KnownLicenseSchema,
+  SkillPackExampleSchema,
+  SkillPackIngestionSchema,
+  SkillPackManifestSchema,
+  SkillPackMcpSchema,
+  SkillPackMcpToolSchema,
+  SkillPackOntologySchema,
+  SkillPackRuntimeSchema,
+  SkillPackRuntimeTypeSchema
+};

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
+};