@stackmemoryai/stackmemory 1.10.5 → 1.12.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,66 @@
+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 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: z.string().default("MIT"),
+  runtime: SkillPackRuntimeSchema.optional(),
+  ingestion: SkillPackIngestionSchema.optional(),
+  ontology: SkillPackOntologySchema.optional(),
+  mcp: SkillPackMcpSchema.optional(),
+  examples: z.array(SkillPackExampleSchema).optional(),
+  instructions: z.string().optional()
+});
+export {
+  SkillPackExampleSchema,
+  SkillPackIngestionSchema,
+  SkillPackManifestSchema,
+  SkillPackMcpSchema,
+  SkillPackMcpToolSchema,
+  SkillPackOntologySchema,
+  SkillPackRuntimeSchema,
+  SkillPackRuntimeTypeSchema
+};

package/dist/src/core/trace/trace-event-store.js

@@ -0,0 +1,282 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { v4 as uuidv4 } from "uuid";
+import { logger } from "../monitoring/logger.js";
+class TraceEventStore {
+  db;
+  constructor(db) {
+    this.db = db;
+    this.initSchema();
+  }
+  initSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS trace_events (
+        id TEXT PRIMARY KEY,
+        timestamp TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        trace_id TEXT NOT NULL,
+        parent_trace_id TEXT,
+        tenant_id TEXT NOT NULL DEFAULT 'local',
+        actor_host TEXT NOT NULL DEFAULT 'unknown',
+        actor_agent TEXT NOT NULL DEFAULT 'stackmemory-mcp',
+        actor_user TEXT NOT NULL DEFAULT 'anonymous',
+        operation TEXT NOT NULL,
+        inputs TEXT NOT NULL DEFAULT '{}',
+        outputs TEXT NOT NULL DEFAULT '{}',
+        tokens_in INTEGER NOT NULL DEFAULT 0,
+        tokens_out INTEGER NOT NULL DEFAULT 0,
+        cost_usd REAL NOT NULL DEFAULT 0,
+        duration_ms INTEGER NOT NULL DEFAULT 0,
+        score REAL,
+        feedback TEXT,
+        provenance TEXT NOT NULL DEFAULT '{"sources":[],"derivation":[],"confidence":1}',
+        error TEXT,
+        tags TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_te_session ON trace_events(session_id);
+      CREATE INDEX IF NOT EXISTS idx_te_trace ON trace_events(trace_id);
+      CREATE INDEX IF NOT EXISTS idx_te_operation ON trace_events(operation);
+      CREATE INDEX IF NOT EXISTS idx_te_timestamp ON trace_events(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_te_score ON trace_events(score) WHERE score IS NOT NULL;
+    `);
+  }
+  // ------------------------------------------------------------------
+  // Write
+  // ------------------------------------------------------------------
+  /**
+   * Record a trace event. Generates ID if not present in trace_id.
+   */
+  record(event) {
+    const id = uuidv4();
+    this.db.prepare(
+      `INSERT INTO trace_events (
+          id, timestamp, session_id, trace_id, parent_trace_id, tenant_id,
+          actor_host, actor_agent, actor_user,
+          operation, inputs, outputs,
+          tokens_in, tokens_out, cost_usd, duration_ms,
+          score, feedback, provenance, error, tags
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      id,
+      event.timestamp,
+      event.session_id,
+      event.trace_id,
+      event.parent_trace_id ?? null,
+      event.tenant_id,
+      event.actor.host,
+      event.actor.agent,
+      event.actor.user,
+      event.operation,
+      JSON.stringify(event.inputs),
+      JSON.stringify(event.outputs),
+      event.tokens_in,
+      event.tokens_out,
+      event.cost_usd,
+      event.duration_ms,
+      event.score ?? null,
+      event.feedback ?? null,
+      JSON.stringify(event.provenance),
+      event.error ?? null,
+      event.tags ? JSON.stringify(event.tags) : null
+    );
+    logger.debug(`TraceEvent recorded: ${event.operation} [${id}]`);
+    return id;
+  }
+  /**
+   * Record multiple events in a single transaction.
+   */
+  recordBatch(events) {
+    const ids = [];
+    this.db.transaction(() => {
+      for (const event of events) {
+        ids.push(this.record(event));
+      }
+    })();
+    return ids;
+  }
+  /**
+   * Add score and/or feedback to an existing event.
+   */
+  annotate(id, annotation) {
+    const sets = [];
+    const params = [];
+    if (annotation.score !== void 0) {
+      sets.push("score = ?");
+      params.push(annotation.score);
+    }
+    if (annotation.feedback !== void 0) {
+      sets.push("feedback = ?");
+      params.push(annotation.feedback);
+    }
+    if (sets.length === 0) return false;
+    params.push(id);
+    const result = this.db.prepare(`UPDATE trace_events SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+    return result.changes > 0;
+  }
+  // ------------------------------------------------------------------
+  // Read
+  // ------------------------------------------------------------------
+  /**
+   * Get a single event by ID.
+   */
+  get(id) {
+    const row = this.db.prepare("SELECT * FROM trace_events WHERE id = ?").get(id);
+    return row ? this.rowToEvent(row) : void 0;
+  }
+  /**
+   * Query events with filters.
+   */
+  query(filter = {}) {
+    const conditions = [];
+    const params = [];
+    if (filter.session_id) {
+      conditions.push("session_id = ?");
+      params.push(filter.session_id);
+    }
+    if (filter.operation) {
+      conditions.push("operation = ?");
+      params.push(filter.operation);
+    }
+    if (filter.min_score !== void 0) {
+      conditions.push("score >= ?");
+      params.push(filter.min_score);
+    }
+    if (filter.has_feedback) {
+      conditions.push("feedback IS NOT NULL");
+    }
+    if (filter.since) {
+      conditions.push("timestamp >= ?");
+      params.push(filter.since);
+    }
+    if (filter.until) {
+      conditions.push("timestamp <= ?");
+      params.push(filter.until);
+    }
+    const where = conditions.length ? "WHERE " + conditions.join(" AND ") : "";
+    const limit = filter.limit ?? 100;
+    const offset = filter.offset ?? 0;
+    const rows = this.db.prepare(
+      `SELECT * FROM trace_events ${where} ORDER BY timestamp DESC LIMIT ? OFFSET ?`
+    ).all(...params, limit, offset);
+    return rows.map((r) => this.rowToEvent(r));
+  }
+  /**
+   * Get events for a specific session.
+   */
+  getBySession(sessionId) {
+    return this.query({ session_id: sessionId, limit: 1e3 });
+  }
+  /**
+   * Get events with scores (for GEPA consumption).
+   */
+  getScoredEvents(minScore) {
+    return this.query({
+      min_score: minScore ?? 0,
+      limit: 500
+    });
+  }
+  /**
+   * Get events with feedback (for GEPA ASI consumption).
+   */
+  getFeedbackEvents() {
+    return this.query({ has_feedback: true, limit: 500 });
+  }
+  // ------------------------------------------------------------------
+  // Stats
+  // ------------------------------------------------------------------
+  /**
+   * Aggregate statistics across all events.
+   */
+  getStats(filter) {
+    const conditions = [];
+    const params = [];
+    if (filter?.session_id) {
+      conditions.push("session_id = ?");
+      params.push(filter.session_id);
+    }
+    if (filter?.since) {
+      conditions.push("timestamp >= ?");
+      params.push(filter.since);
+    }
+    const where = conditions.length ? "WHERE " + conditions.join(" AND ") : "";
+    const agg = this.db.prepare(
+      `SELECT
+          COUNT(*) as total_events,
+          COALESCE(SUM(tokens_in), 0) as total_tokens_in,
+          COALESCE(SUM(tokens_out), 0) as total_tokens_out,
+          COALESCE(SUM(cost_usd), 0) as total_cost_usd,
+          AVG(score) as avg_score,
+          SUM(CASE WHEN feedback IS NOT NULL THEN 1 ELSE 0 END) as events_with_feedback,
+          SUM(CASE WHEN error IS NOT NULL THEN 1 ELSE 0 END) as events_with_errors
+        FROM trace_events ${where}`
+    ).get(...params);
+    const opRows = this.db.prepare(
+      `SELECT operation, COUNT(*) as cnt FROM trace_events ${where} GROUP BY operation ORDER BY cnt DESC`
+    ).all(...params);
+    const hostRows = this.db.prepare(
+      `SELECT actor_host, COUNT(*) as cnt FROM trace_events ${where} GROUP BY actor_host ORDER BY cnt DESC`
+    ).all(...params);
+    const operations = {};
+    for (const r of opRows) operations[r.operation] = r.cnt;
+    const hosts = {};
+    for (const r of hostRows) hosts[r.actor_host] = r.cnt;
+    return {
+      total_events: agg["total_events"] || 0,
+      total_tokens_in: agg["total_tokens_in"] || 0,
+      total_tokens_out: agg["total_tokens_out"] || 0,
+      total_cost_usd: agg["total_cost_usd"] || 0,
+      avg_score: agg["avg_score"],
+      events_with_feedback: agg["events_with_feedback"] || 0,
+      events_with_errors: agg["events_with_errors"] || 0,
+      operations,
+      hosts
+    };
+  }
+  // ------------------------------------------------------------------
+  // Lifecycle
+  // ------------------------------------------------------------------
+  /**
+   * Delete events older than the given ISO timestamp.
+   */
+  evict(olderThan) {
+    const result = this.db.prepare("DELETE FROM trace_events WHERE timestamp < ?").run(olderThan);
+    return result.changes;
+  }
+  // ------------------------------------------------------------------
+  // Helpers
+  // ------------------------------------------------------------------
+  rowToEvent(row) {
+    const provenance = JSON.parse(row.provenance);
+    const actor = {
+      host: row.actor_host,
+      agent: row.actor_agent,
+      user: row.actor_user
+    };
+    return {
+      timestamp: row.timestamp,
+      session_id: row.session_id,
+      trace_id: row.trace_id,
+      parent_trace_id: row.parent_trace_id ?? void 0,
+      tenant_id: row.tenant_id,
+      actor,
+      operation: row.operation,
+      inputs: JSON.parse(row.inputs),
+      outputs: JSON.parse(row.outputs),
+      tokens_in: row.tokens_in,
+      tokens_out: row.tokens_out,
+      cost_usd: row.cost_usd,
+      duration_ms: row.duration_ms,
+      score: row.score ?? void 0,
+      feedback: row.feedback ?? void 0,
+      provenance,
+      error: row.error ?? void 0,
+      tags: row.tags ? JSON.parse(row.tags) : void 0
+    };
+  }
+}
+export {
+  TraceEventStore
+};

package/dist/src/core/trace/trace-event.js

@@ -0,0 +1,4 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);

package/dist/src/daemon/daemon-config.js

@@ -23,6 +23,10 @@ const DEFAULT_DAEMON_CONFIG = {
     retryAttempts: 3,
     retryDelay: 3e4
   },
+  github: {
+    enabled: false,
+    interval: 5
+  },
   maintenance: {
     enabled: true,
     interval: 360,
@@ -96,6 +100,7 @@ function loadDaemonConfig() {
       ...config,
       context: { ...DEFAULT_DAEMON_CONFIG.context, ...config.context },
       linear: { ...DEFAULT_DAEMON_CONFIG.linear, ...config.linear },
+      github: { ...DEFAULT_DAEMON_CONFIG.github, ...config.github },
       maintenance: {
         ...DEFAULT_DAEMON_CONFIG.maintenance,
         ...config.maintenance
@@ -115,6 +120,7 @@ function saveDaemonConfig(config) {
     ...config,
     context: { ...currentConfig.context, ...config.context },
     linear: { ...currentConfig.linear, ...config.linear },
+    github: { ...currentConfig.github, ...config.github },
     maintenance: { ...currentConfig.maintenance, ...config.maintenance },
     memory: { ...currentConfig.memory, ...config.memory },
     fileWatch: { ...currentConfig.fileWatch, ...config.fileWatch }
@@ -128,6 +134,7 @@ function readDaemonStatus() {
     services: {
       context: { enabled: false },
       linear: { enabled: false },
+      github: { enabled: false },
       maintenance: { enabled: false },
       memory: { enabled: false },
       fileWatch: { enabled: false }