@stackmemoryai/stackmemory 1.10.5 → 1.14.0

package/dist/src/core/patterns/pattern-observer.js

@@ -0,0 +1,157 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+class PatternObserver {
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Analyze a session's trace events and extract patterns.
+   * Call at session_end with the session's trace events.
+   */
+  observe(events, projectId) {
+    if (events.length < 3) return [];
+    const learned = [];
+    const sequences = this.findRepeatedSequences(events);
+    for (const seq of sequences) {
+      const id = this.sequenceId(seq.operations);
+      const existing = this.store.get(id);
+      if (existing) {
+        this.store.reinforce(id, `Session observation (${seq.count}x)`);
+      } else {
+        this.store.create({
+          id,
+          domain: this.inferDomain(seq.operations),
+          trigger: `When performing a ${this.describeIntent(seq.operations)} workflow`,
+          action: `Follow sequence: ${seq.operations.join(" \u2192 ")}`,
+          evidence: [`Observed ${seq.count}x in session`],
+          scope: projectId ? "project" : "global",
+          projectId,
+          source: "observed"
+        });
+      }
+      learned.push(id);
+    }
+    const errorFixes = this.findErrorFixPairs(events);
+    for (const { error, fix } of errorFixes) {
+      const id = `fix-${this.slugify(error.operation)}-${this.slugify(fix.operation)}`;
+      const existing = this.store.get(id);
+      if (existing) {
+        this.store.reinforce(
+          id,
+          `Error\u2192fix: ${error.error} \u2192 ${fix.operation}`
+        );
+      } else {
+        this.store.create({
+          id,
+          domain: "debugging",
+          trigger: `When encountering error in ${error.operation}`,
+          action: `Resolve with ${fix.operation}: ${this.summarizeInputs(fix)}`,
+          evidence: [`Error: ${error.error?.slice(0, 200)}`],
+          scope: projectId ? "project" : "global",
+          projectId,
+          source: "observed"
+        });
+      }
+      learned.push(id);
+    }
+    const preferences = this.findToolPreferences(events);
+    for (const { before, after, count } of preferences) {
+      const id = `prefer-${this.slugify(before)}-before-${this.slugify(after)}`;
+      const existing = this.store.get(id);
+      if (existing) {
+        this.store.reinforce(id, `${before}\u2192${after} (${count}x)`);
+      } else if (count >= 3) {
+        this.store.create({
+          id,
+          domain: "workflow",
+          trigger: `When about to use ${after}`,
+          action: `Use ${before} first`,
+          evidence: [`Observed ${count}x: ${before} always precedes ${after}`],
+          scope: "global",
+          source: "observed"
+        });
+        learned.push(id);
+      }
+    }
+    return learned;
+  }
+  // ── Sequence Detection ────────────────────────────────
+  findRepeatedSequences(events) {
+    const ops = events.map((e) => e.operation);
+    const sequences = /* @__PURE__ */ new Map();
+    for (let windowSize = 2; windowSize <= 4; windowSize++) {
+      for (let i = 0; i <= ops.length - windowSize; i++) {
+        const seq = ops.slice(i, i + windowSize);
+        const key = seq.join("\u2192");
+        const existing = sequences.get(key);
+        if (existing) {
+          existing.count++;
+        } else {
+          sequences.set(key, { operations: seq, count: 1 });
+        }
+      }
+    }
+    return Array.from(sequences.values()).filter((s) => s.count >= 3);
+  }
+  // ── Error→Fix Detection ───────────────────────────────
+  findErrorFixPairs(events) {
+    const pairs = [];
+    for (let i = 0; i < events.length - 1; i++) {
+      const event = events[i];
+      if (!event.error) continue;
+      for (let j = i + 1; j < Math.min(i + 4, events.length); j++) {
+        const next = events[j];
+        if (!next.error) {
+          pairs.push({ error: event, fix: next });
+          break;
+        }
+      }
+    }
+    return pairs;
+  }
+  // ── Tool Preference Detection ─────────────────────────
+  findToolPreferences(events) {
+    const pairs = /* @__PURE__ */ new Map();
+    const ops = events.map((e) => e.operation);
+    for (let i = 0; i < ops.length - 1; i++) {
+      const key = `${ops[i]}\u2192${ops[i + 1]}`;
+      pairs.set(key, (pairs.get(key) ?? 0) + 1);
+    }
+    return Array.from(pairs.entries()).filter(([, count]) => count >= 3).map(([key, count]) => {
+      const [before, after] = key.split("\u2192");
+      return { before, after, count };
+    });
+  }
+  // ── Helpers ───────────────────────────────────────────
+  sequenceId(ops) {
+    return `seq-${ops.map((o) => this.slugify(o)).join("-")}`;
+  }
+  slugify(s) {
+    return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 30);
+  }
+  inferDomain(ops) {
+    const joined = ops.join(" ").toLowerCase();
+    if (/test|vitest|jest/.test(joined)) return "testing";
+    if (/git|commit|branch|push/.test(joined)) return "git";
+    if (/grep|glob|read|search/.test(joined)) return "workflow";
+    if (/edit|write/.test(joined)) return "code-style";
+    if (/security|auth|token/.test(joined)) return "security";
+    return "general";
+  }
+  describeIntent(ops) {
+    const unique = [...new Set(ops)];
+    if (unique.length <= 2) return unique.join(" + ");
+    return `${unique[0]} \u2192 ${unique[unique.length - 1]}`;
+  }
+  summarizeInputs(event) {
+    const inputs = event.inputs;
+    if (!inputs || typeof inputs !== "object") return "";
+    const keys = Object.keys(inputs).slice(0, 3);
+    return keys.join(", ");
+  }
+}
+export {
+  PatternObserver
+};

package/dist/src/core/patterns/pattern-store.js

@@ -0,0 +1,259 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  computeConfidence,
+  CONFIDENCE_DECAY_PER_WEEK,
+  CONFIDENCE_BOOST_PER_OBSERVATION
+} from "./types.js";
+class PatternStore {
+  constructor(db) {
+    this.db = db;
+  }
+  /** Create a new pattern */
+  create(input) {
+    const now = Date.now();
+    const confidence = input.confidence ?? computeConfidence(1);
+    this.db.prepare(
+      `
+      INSERT INTO patterns (id, domain, trigger, action, evidence, confidence, observation_count, scope, project_id, status, source, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `
+    ).run(
+      input.id,
+      input.domain,
+      input.trigger,
+      input.action,
+      JSON.stringify(input.evidence ?? []),
+      confidence,
+      1,
+      input.scope ?? "project",
+      input.projectId ?? null,
+      "pending",
+      input.source ?? "manual",
+      now,
+      now
+    );
+    return this.get(input.id);
+  }
+  /** Get a pattern by ID */
+  get(id) {
+    const row = this.db.prepare("SELECT * FROM patterns WHERE id = ?").get(id);
+    return row ? this.toPattern(row) : void 0;
+  }
+  /** List patterns with filtering */
+  list(query = {}) {
+    const conditions = [];
+    const params = [];
+    if (query.domain) {
+      conditions.push("domain = ?");
+      params.push(query.domain);
+    }
+    if (query.status) {
+      conditions.push("status = ?");
+      params.push(query.status);
+    }
+    if (query.scope) {
+      conditions.push("scope = ?");
+      params.push(query.scope);
+    }
+    if (query.projectId) {
+      conditions.push("(project_id = ? OR scope = 'global')");
+      params.push(query.projectId);
+    }
+    if (query.minConfidence !== void 0) {
+      conditions.push("confidence >= ?");
+      params.push(query.minConfidence);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = query.limit ?? 100;
+    const rows = this.db.prepare(
+      `SELECT * FROM patterns ${where} ORDER BY confidence DESC, updated_at DESC LIMIT ?`
+    ).all(...params, limit);
+    return rows.map((r) => this.toPattern(r));
+  }
+  /** Record an observation that reinforces a pattern */
+  reinforce(id, evidence) {
+    const pattern = this.get(id);
+    if (!pattern) return;
+    const newCount = pattern.observationCount + 1;
+    const baseConfidence = computeConfidence(newCount);
+    const boosted = Math.min(
+      1,
+      baseConfidence + CONFIDENCE_BOOST_PER_OBSERVATION
+    );
+    const newEvidence = [...pattern.evidence, evidence].slice(-20);
+    this.db.prepare(
+      `
+      UPDATE patterns
+      SET observation_count = ?, confidence = ?, evidence = ?, updated_at = ?, status = CASE WHEN status = 'pending' AND ? >= 0.5 THEN 'active' ELSE status END
+      WHERE id = ?
+    `
+    ).run(
+      newCount,
+      boosted,
+      JSON.stringify(newEvidence),
+      Date.now(),
+      boosted,
+      id
+    );
+  }
+  /** Apply weekly confidence decay to all patterns */
+  applyDecay() {
+    const oneWeekAgo = Date.now() - 7 * 24 * 60 * 60 * 1e3;
+    const result = this.db.prepare(
+      `
+      UPDATE patterns
+      SET confidence = MAX(0.05, confidence - ?),
+          updated_at = ?
+      WHERE updated_at < ? AND status != 'archived'
+    `
+    ).run(CONFIDENCE_DECAY_PER_WEEK, Date.now(), oneWeekAgo);
+    return result.changes;
+  }
+  /** Mark a pattern as matched during retrieval */
+  recordMatch(id) {
+    this.db.prepare("UPDATE patterns SET last_matched_at = ? WHERE id = ?").run(Date.now(), id);
+  }
+  /** Activate a pending pattern */
+  activate(id) {
+    this.db.prepare(
+      "UPDATE patterns SET status = 'active', updated_at = ? WHERE id = ?"
+    ).run(Date.now(), id);
+  }
+  /** Archive a pattern */
+  archive(id, supersededBy) {
+    this.db.prepare(
+      "UPDATE patterns SET status = 'archived', superseded_by = ?, updated_at = ? WHERE id = ?"
+    ).run(supersededBy ?? null, Date.now(), id);
+  }
+  /** Prune old pending patterns that never got promoted */
+  prune(maxAgeDays = 30) {
+    const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
+    const result = this.db.prepare(
+      "DELETE FROM patterns WHERE status = 'pending' AND created_at < ?"
+    ).run(cutoff);
+    return result.changes;
+  }
+  /** Get aggregate stats */
+  stats() {
+    const all = this.list({ limit: 1e3 });
+    const byDomain = {};
+    const byStatus = {};
+    let totalConfidence = 0;
+    for (const p of all) {
+      byDomain[p.domain] = (byDomain[p.domain] ?? 0) + 1;
+      byStatus[p.status] = (byStatus[p.status] ?? 0) + 1;
+      totalConfidence += p.confidence;
+    }
+    const topPatterns = all.filter((p) => p.status === "active").slice(0, 10).map((p) => ({ id: p.id, confidence: p.confidence, trigger: p.trigger }));
+    return {
+      total: all.length,
+      byDomain,
+      byStatus,
+      avgConfidence: all.length > 0 ? totalConfidence / all.length : 0,
+      topPatterns
+    };
+  }
+  /** Promote a project-scoped pattern to global */
+  promote(id) {
+    this.db.prepare(
+      "UPDATE patterns SET scope = 'global', project_id = NULL, updated_at = ? WHERE id = ?"
+    ).run(Date.now(), id);
+  }
+  /** List distinct project IDs with pattern counts */
+  projects() {
+    const rows = this.db.prepare(
+      `
+      SELECT project_id, COUNT(*) as count, AVG(confidence) as avg_confidence
+      FROM patterns
+      WHERE project_id IS NOT NULL AND status != 'archived'
+      GROUP BY project_id
+      ORDER BY count DESC
+    `
+    ).all();
+    return rows.map((r) => ({
+      projectId: r.project_id,
+      count: r.count,
+      avgConfidence: r.avg_confidence
+    }));
+  }
+  /** Find patterns that appear in 2+ projects (promotion candidates) */
+  promotionCandidates(minConfidence = 0.7) {
+    const rows = this.db.prepare(
+      `
+      SELECT p1.* FROM patterns p1
+      WHERE p1.scope = 'project'
+        AND p1.confidence >= ?
+        AND p1.status = 'active'
+        AND EXISTS (
+          SELECT 1 FROM patterns p2
+          WHERE p2.trigger = p1.trigger
+            AND p2.action = p1.action
+            AND p2.project_id != p1.project_id
+            AND p2.status = 'active'
+        )
+      ORDER BY p1.confidence DESC
+    `
+    ).all(minConfidence);
+    return rows.map((r) => this.toPattern(r));
+  }
+  /** Find clusters of related patterns (for evolve) */
+  findClusters(minSize = 2) {
+    const active = this.list({ status: "active", limit: 500 });
+    const byDomain = /* @__PURE__ */ new Map();
+    for (const p of active) {
+      const list = byDomain.get(p.domain) ?? [];
+      list.push(p);
+      byDomain.set(p.domain, list);
+    }
+    return Array.from(byDomain.entries()).filter(([, patterns]) => patterns.length >= minSize).map(([domain, patterns]) => ({
+      domain,
+      patterns: patterns.sort((a, b) => b.confidence - a.confidence)
+    }));
+  }
+  /** Find patterns relevant to a query string */
+  search(query, projectId) {
+    const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (words.length === 0) return [];
+    const candidates = this.list({
+      status: "active",
+      projectId,
+      minConfidence: 0.3,
+      limit: 200
+    });
+    const scored = candidates.map((p) => {
+      const text = `${p.trigger} ${p.action} ${p.domain}`.toLowerCase();
+      const hits = words.filter((w) => text.includes(w)).length;
+      const score = hits / words.length;
+      return { pattern: p, score };
+    });
+    return scored.filter((s) => s.score > 0.2).sort(
+      (a, b) => b.score * b.pattern.confidence - a.score * a.pattern.confidence
+    ).slice(0, 10).map((s) => s.pattern);
+  }
+  // ── Private ───────────────────────────────────────────
+  toPattern(row) {
+    return {
+      id: row.id,
+      domain: row.domain,
+      trigger: row.trigger,
+      action: row.action,
+      evidence: JSON.parse(row.evidence || "[]"),
+      confidence: row.confidence,
+      observationCount: row.observation_count,
+      scope: row.scope,
+      projectId: row.project_id,
+      status: row.status,
+      source: row.source,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      lastMatchedAt: row.last_matched_at,
+      supersededBy: row.superseded_by
+    };
+  }
+}
+export {
+  PatternStore
+};

package/dist/src/core/patterns/types.js

@@ -0,0 +1,19 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+function computeConfidence(observationCount) {
+  if (observationCount >= 11) return 0.85;
+  if (observationCount >= 6) return 0.7;
+  if (observationCount >= 3) return 0.5;
+  return 0.3;
+}
+const CONFIDENCE_DECAY_PER_WEEK = 0.02;
+const CONFIDENCE_BOOST_PER_OBSERVATION = 0.05;
+const CONFIDENCE_PENALTY_PER_CONTRADICTION = 0.1;
+export {
+  CONFIDENCE_BOOST_PER_OBSERVATION,
+  CONFIDENCE_DECAY_PER_WEEK,
+  CONFIDENCE_PENALTY_PER_CONTRADICTION,
+  computeConfidence
+};

package/dist/src/core/provenance/confidence-scorer.js

@@ -0,0 +1,128 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+const TRIGGER_PHRASES = [
+  "we decided",
+  "the plan is",
+  "going forward",
+  "action item",
+  "let's go with",
+  "agreed to",
+  "we're doing",
+  "approved",
+  "confirmed",
+  "the approach is",
+  "final answer",
+  "ship it",
+  "green light",
+  "sign off",
+  "consensus is"
+];
+const HEDGE_PHRASES = [
+  "maybe",
+  "might",
+  "not sure",
+  "i think",
+  "possibly",
+  "perhaps",
+  "could be",
+  "uncertain",
+  "don't know",
+  "unclear"
+];
+const IMPERATIVE_VERBS = [
+  "use",
+  "deploy",
+  "migrate",
+  "switch",
+  "remove",
+  "add",
+  "implement",
+  "create",
+  "delete",
+  "update",
+  "replace",
+  "refactor",
+  "integrate",
+  "configure",
+  "enable",
+  "disable"
+];
+const WEIGHTS = {
+  triggerPhrase: 0.3,
+  triggerPhraseCap: 0.6,
+  imperativeVerb: 0.15,
+  actorAttribution: 0.1,
+  recencyBonus: 0.1,
+  replyCountBonus: 0.05,
+  questionPenalty: -0.2,
+  hedgePenalty: -0.15
+};
+const THRESHOLDS = {
+  accept: 0.7,
+  review: 0.4
+};
+const RECENCY_WINDOW_MS = 48 * 60 * 60 * 1e3;
+function scoreConfidence(text, context = {}) {
+  const lower = (text || "").toLowerCase();
+  const signals = {};
+  let score = 0;
+  const matchedTriggers = TRIGGER_PHRASES.filter((p) => lower.includes(p));
+  const triggerScore = Math.min(
+    matchedTriggers.length * WEIGHTS.triggerPhrase,
+    WEIGHTS.triggerPhraseCap
+  );
+  if (triggerScore > 0) {
+    signals["triggerPhrases"] = matchedTriggers;
+    score += triggerScore;
+  }
+  const sentences = lower.split(/[.!?\n]+/).map((s) => s.trim()).filter(Boolean);
+  const hasImperative = sentences.some((s) => {
+    const firstWord = s.split(/\s+/)[0];
+    return IMPERATIVE_VERBS.includes(firstWord ?? "");
+  });
+  if (hasImperative) {
+    signals["imperativeVerb"] = true;
+    score += WEIGHTS.imperativeVerb;
+  }
+  if (context.actor) {
+    signals["actorAttribution"] = context.actor;
+    score += WEIGHTS.actorAttribution;
+  }
+  if (context.relatedTicketDate && context.messageDate) {
+    const ticketTime = new Date(context.relatedTicketDate).getTime();
+    const msgTime = new Date(context.messageDate).getTime();
+    const diff = Math.abs(msgTime - ticketTime);
+    if (diff <= RECENCY_WINDOW_MS) {
+      signals["recencyBonus"] = true;
+      score += WEIGHTS.recencyBonus;
+    }
+  }
+  if (context.replyCount !== void 0 && context.replyCount > 2) {
+    signals["replyCountBonus"] = context.replyCount;
+    score += WEIGHTS.replyCountBonus;
+  }
+  const isQuestion = /\?\s*$/.test(text.trim()) || lower.startsWith("should we") || lower.startsWith("what if");
+  if (isQuestion) {
+    signals["questionPenalty"] = true;
+    score += WEIGHTS.questionPenalty;
+  }
+  const matchedHedges = HEDGE_PHRASES.filter((p) => lower.includes(p));
+  if (matchedHedges.length > 0) {
+    signals["hedgePhrases"] = matchedHedges;
+    score += WEIGHTS.hedgePenalty;
+  }
+  const confidence = Math.max(0, Math.min(1, score));
+  const classification = confidence >= THRESHOLDS.accept ? "accept" : confidence >= THRESHOLDS.review ? "review" : "discard";
+  return { confidence, signals, classification };
+}
+export {
+  HEDGE_PHRASES,
+  IMPERATIVE_VERBS,
+  RECENCY_WINDOW_MS,
+  THRESHOLDS,
+  TRIGGER_PHRASES,
+  WEIGHTS,
+  scoreConfidence
+};

package/dist/src/core/provenance/index.js

@@ -0,0 +1,40 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  SourceRefSchema,
+  ProvenanceRecordSchema,
+  ActorSchema,
+  TraceEventSchema,
+  ConfidenceClassificationSchema,
+  ConfidenceScoreSchema,
+  ConfidenceConfigSchema
+} from "./types.js";
+import {
+  scoreConfidence,
+  TRIGGER_PHRASES,
+  HEDGE_PHRASES,
+  IMPERATIVE_VERBS,
+  WEIGHTS,
+  THRESHOLDS,
+  RECENCY_WINDOW_MS
+} from "./confidence-scorer.js";
+import { ProvenanceStore } from "./provenance-store.js";
+export {
+  ActorSchema,
+  ConfidenceClassificationSchema,
+  ConfidenceConfigSchema,
+  ConfidenceScoreSchema,
+  HEDGE_PHRASES,
+  IMPERATIVE_VERBS,
+  ProvenanceRecordSchema,
+  ProvenanceStore,
+  RECENCY_WINDOW_MS,
+  SourceRefSchema,
+  THRESHOLDS,
+  TRIGGER_PHRASES,
+  TraceEventSchema,
+  WEIGHTS,
+  scoreConfidence
+};