@stackmemoryai/stackmemory 1.9.0 → 1.10.2

package/dist/src/core/rules/built-in-rules.js

@@ -0,0 +1,289 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { prReviewRule } from "./pr-review-rule.js";
+function violation(ruleId, ruleName, severity, message, file, line, suggestion) {
+  return { ruleId, ruleName, severity, message, file, line, suggestion };
+}
+function pass() {
+  return { passed: true, violations: [] };
+}
+function fail(violations) {
+  return { passed: false, violations };
+}
+function escapeGlobPart(part) {
+  return part.replace(/\./g, "\\.").replace(
+    /\{([^}]+)\}/g,
+    (_m, choices) => `(${choices.split(",").join("|")})`
+  ).replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+}
+function globToRegex(pattern) {
+  if (pattern.startsWith("**/")) {
+    const rest = escapeGlobPart(pattern.slice(3));
+    return new RegExp(`^(?:.+/)?${rest}$`);
+  }
+  const parts = pattern.split("/**/");
+  if (parts.length === 1) {
+    return new RegExp(`^${escapeGlobPart(pattern)}$`);
+  }
+  const regexParts = parts.map(escapeGlobPart);
+  return new RegExp(`^${regexParts.join("(?:/.*?/|/)")}$`);
+}
+function matchesScope(filePath, scope) {
+  if (scope === "**/*" || scope === "*") return true;
+  const re = globToRegex(scope);
+  return re.test(filePath);
+}
+function filterByScope(files, scope) {
+  return files.filter((f) => matchesScope(f, scope));
+}
+const noCoauthor = {
+  id: "no-coauthor",
+  name: "No Co-Authored-By",
+  description: "Block Co-Authored-By lines in commit messages",
+  trigger: "commit",
+  severity: "error",
+  scope: "*",
+  enabled: true,
+  builtin: true,
+  check(ctx) {
+    if (!ctx.commitMessage) return pass();
+    if (/co-authored-by/i.test(ctx.commitMessage)) {
+      return fail([
+        violation(
+          this.id,
+          this.name,
+          this.severity,
+          "Commit message contains Co-Authored-By line",
+          void 0,
+          void 0,
+          "Remove the Co-Authored-By trailer"
+        )
+      ]);
+    }
+    return pass();
+  }
+};
+const noJestGlobals = {
+  id: "no-jest-globals",
+  name: "No @jest/globals imports",
+  description: "Flag @jest/globals imports in src/ tests (causes redeclaration errors)",
+  trigger: "lint",
+  severity: "error",
+  scope: "src/**/*.test.{ts,js}",
+  enabled: true,
+  builtin: true,
+  check(ctx) {
+    const violations = [];
+    const files = filterByScope(ctx.files, this.scope);
+    for (const file of files) {
+      const content = ctx.content.get(file);
+      if (!content) continue;
+      const lines = content.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line && /@jest\/globals/.test(line)) {
+          violations.push(
+            violation(
+              this.id,
+              this.name,
+              this.severity,
+              `Import from @jest/globals found \u2014 use global jest instead`,
+              file,
+              i + 1,
+              "Remove the import; jest/describe/it/expect are globally available"
+            )
+          );
+        }
+      }
+    }
+    return violations.length > 0 ? fail(violations) : pass();
+  }
+};
+const catchNoUnderscore = {
+  id: "catch-no-underscore",
+  name: "Catch without underscore prefix",
+  description: "Enforce catch {} not catch (_err) {} \u2014 underscore prefix not in allowed ESLint pattern",
+  trigger: "lint",
+  severity: "warn",
+  scope: "src/**/*.{ts,js}",
+  enabled: true,
+  builtin: true,
+  check(ctx) {
+    const violations = [];
+    const files = filterByScope(ctx.files, this.scope);
+    for (const file of files) {
+      const content = ctx.content.get(file);
+      if (!content) continue;
+      const lines = content.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line && /catch\s*\(\s*_\w*\s*\)/.test(line)) {
+          violations.push(
+            violation(
+              this.id,
+              this.name,
+              this.severity,
+              "catch with underscore-prefixed variable",
+              file,
+              i + 1,
+              "Use catch {} (empty) or catch (err) {} (without underscore)"
+            )
+          );
+        }
+      }
+    }
+    return violations.length > 0 ? fail(violations) : pass();
+  }
+};
+const THROW_EXCLUDE_PATTERNS = [
+  /middleware/i,
+  /errors?\//i,
+  /errors?\.(ts|js)$/i,
+  /index\.(ts|js)$/,
+  /\.test\.(ts|js)$/,
+  /__tests__/
+];
+const returnDontThrow = {
+  id: "return-dont-throw",
+  name: "Return undefined over throw",
+  description: "Warn on throw in non-boundary code \u2014 prefer return undefined + log",
+  trigger: "lint",
+  severity: "info",
+  scope: "src/**/*.{ts,js}",
+  enabled: true,
+  builtin: true,
+  check(ctx) {
+    const violations = [];
+    const files = filterByScope(ctx.files, this.scope);
+    for (const file of files) {
+      if (THROW_EXCLUDE_PATTERNS.some((p) => p.test(file))) continue;
+      const content = ctx.content.get(file);
+      if (!content) continue;
+      const lines = content.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line && /throw\s+new\s+/.test(line)) {
+          violations.push(
+            violation(
+              this.id,
+              this.name,
+              this.severity,
+              "throw statement in non-boundary code",
+              file,
+              i + 1,
+              "Consider returning undefined and logging the error instead"
+            )
+          );
+        }
+      }
+    }
+    return violations.length > 0 ? fail(violations) : pass();
+  }
+};
+const migrationSequential = {
+  id: "migration-sequential",
+  name: "Sequential migration numbering",
+  description: "Validate migration files have no numbering gaps",
+  trigger: "on-demand",
+  severity: "error",
+  scope: "**/migrations/*.sql",
+  enabled: true,
+  builtin: true,
+  check(ctx) {
+    const files = filterByScope(ctx.files, this.scope);
+    const numbers = [];
+    for (const file of files) {
+      const basename = file.split("/").pop() ?? "";
+      const match = /^(\d+)/.exec(basename);
+      if (match?.[1]) {
+        numbers.push(parseInt(match[1], 10));
+      }
+    }
+    if (numbers.length < 2) return pass();
+    numbers.sort((a, b) => a - b);
+    const violations = [];
+    for (let i = 1; i < numbers.length; i++) {
+      const prev = numbers[i - 1];
+      const curr = numbers[i];
+      if (curr - prev > 1) {
+        violations.push(
+          violation(
+            this.id,
+            this.name,
+            this.severity,
+            `Migration gap: ${String(prev).padStart(3, "0")} \u2192 ${String(curr).padStart(3, "0")} (missing ${curr - prev - 1} file(s))`,
+            void 0,
+            void 0,
+            `Add migration(s) for numbers ${prev + 1}\u2013${curr - 1}`
+          )
+        );
+      }
+    }
+    return violations.length > 0 ? fail(violations) : pass();
+  }
+};
+const mockLifecycle = {
+  id: "mock-lifecycle",
+  name: "Mock lifecycle in tests",
+  description: "Warn if clearAllMocks() is called without re-setting mocks in beforeEach",
+  trigger: "lint",
+  severity: "warn",
+  scope: "src/**/*.test.{ts,js}",
+  enabled: true,
+  builtin: true,
+  check(ctx) {
+    const violations = [];
+    const files = filterByScope(ctx.files, this.scope);
+    for (const file of files) {
+      const content = ctx.content.get(file);
+      if (!content) continue;
+      const hasClearAll = /clearAllMocks\(\)/.test(content);
+      if (!hasClearAll) continue;
+      const hasBeforeEach = /beforeEach/.test(content);
+      const hasMockSetup = /mock(ReturnValue|ResolvedValue|Implementation)\s*\(/.test(content);
+      if (hasClearAll && hasBeforeEach && !hasMockSetup) {
+        violations.push(
+          violation(
+            this.id,
+            this.name,
+            this.severity,
+            "clearAllMocks() used but no mock re-setup found (mockReturnValue/mockResolvedValue/mockImplementation)",
+            file,
+            void 0,
+            "Re-set mock return values in beforeEach after clearAllMocks resets them"
+          )
+        );
+      }
+    }
+    return violations.length > 0 ? fail(violations) : pass();
+  }
+};
+const BUILT_IN_RULES = [
+  noCoauthor,
+  noJestGlobals,
+  catchNoUnderscore,
+  returnDontThrow,
+  migrationSequential,
+  mockLifecycle,
+  prReviewRule
+];
+function getBuiltinRows() {
+  return BUILT_IN_RULES.map((r) => ({
+    id: r.id,
+    name: r.name,
+    description: r.description,
+    trigger_type: r.trigger,
+    severity: r.severity,
+    scope: r.scope,
+    enabled: r.enabled ? 1 : 0,
+    builtin: r.builtin ? 1 : 0
+  }));
+}
+export {
+  BUILT_IN_RULES,
+  filterByScope,
+  getBuiltinRows,
+  matchesScope
+};

package/dist/src/core/rules/pr-review-rule.js

@@ -0,0 +1,87 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { filterByScope } from "./built-in-rules.js";
+function violation(ruleId, ruleName, severity, message, file, line, suggestion) {
+  return { ruleId, ruleName, severity, message, file, line, suggestion };
+}
+const PR_REVIEW_PATTERNS = [
+  {
+    id: "console-log",
+    pattern: /console\.(log|debug|info)\(/,
+    message: "console.log left in code",
+    suggestion: "Remove or replace with structured logger",
+    severity: "warn"
+  },
+  {
+    id: "todo-fixme",
+    pattern: /\/\/\s*(TODO|FIXME|HACK|XXX)(?!\s*\()/,
+    message: "TODO/FIXME without attribution",
+    suggestion: "Add author and ticket: // TODO(user): STA-XXX description",
+    severity: "info"
+  },
+  {
+    id: "hardcoded-secret",
+    pattern: /(api[_-]?key|secret|password|token)\s*[:=]\s*['"][^'"]{8,}['"]/i,
+    message: "Possible hardcoded secret",
+    suggestion: "Move to environment variable",
+    severity: "error"
+  },
+  {
+    id: "any-type",
+    pattern: /:\s*any\b/,
+    message: "Explicit any type",
+    suggestion: "Use a specific type or unknown",
+    severity: "warn"
+  },
+  {
+    id: "empty-catch",
+    pattern: /catch\s*\{[\s]*\}/,
+    message: "Empty catch block (swallows errors silently)",
+    suggestion: "Log the error or add a comment explaining why it is safe to ignore",
+    severity: "warn"
+  }
+];
+const prReviewRule = {
+  id: "pr-review-patterns",
+  name: "PR Review Patterns",
+  description: "Catch common issues that PR reviewers flag (console.log, TODO, secrets, any type)",
+  trigger: "pre-commit",
+  severity: "warn",
+  scope: "src/**/*.{ts,js,tsx,jsx}",
+  enabled: true,
+  builtin: true,
+  check(ctx) {
+    const violations = [];
+    const files = filterByScope(ctx.files, this.scope);
+    for (const file of files) {
+      const content = ctx.content.get(file);
+      if (!content) continue;
+      const lines = content.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line) continue;
+        for (const check of PR_REVIEW_PATTERNS) {
+          if (check.pattern.test(line)) {
+            violations.push(
+              violation(
+                this.id,
+                `${this.name}: ${check.id}`,
+                check.severity,
+                check.message,
+                file,
+                i + 1,
+                check.suggestion
+              )
+            );
+          }
+        }
+      }
+    }
+    return violations.length > 0 ? { passed: false, violations } : { passed: true, violations: [] };
+  }
+};
+export {
+  prReviewRule
+};

package/dist/src/core/rules/rule-engine.js

@@ -0,0 +1,85 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { RuleStore } from "./rule-store.js";
+import {
+  BUILT_IN_RULES,
+  getBuiltinRows,
+  filterByScope
+} from "./built-in-rules.js";
+class RuleEngine {
+  store;
+  checkFns = /* @__PURE__ */ new Map();
+  constructor(db) {
+    this.store = new RuleStore(db);
+    this.store.seedBuiltins(getBuiltinRows());
+    for (const rule of BUILT_IN_RULES) {
+      this.checkFns.set(rule.id, rule.check.bind(rule));
+    }
+  }
+  registerRule(rule) {
+    this.store.upsert({
+      id: rule.id,
+      name: rule.name,
+      description: rule.description,
+      trigger_type: rule.trigger,
+      severity: rule.severity,
+      scope: rule.scope,
+      enabled: rule.enabled ? 1 : 0,
+      builtin: rule.builtin ? 1 : 0
+    });
+    this.checkFns.set(rule.id, rule.check.bind(rule));
+  }
+  evaluate(context) {
+    const rows = this.store.getByTrigger(context.trigger);
+    return this.runRules(rows, context);
+  }
+  evaluateAll(context) {
+    const rows = this.store.getEnabled();
+    return this.runRules(rows, context);
+  }
+  listRules(filter) {
+    if (filter?.trigger) {
+      return this.store.getByTrigger(filter.trigger);
+    }
+    if (filter?.enabled === false) {
+      return this.store.getAll();
+    }
+    return this.store.getEnabled();
+  }
+  enableRule(id) {
+    return this.store.setEnabled(id, true);
+  }
+  disableRule(id) {
+    return this.store.setEnabled(id, false);
+  }
+  getStore() {
+    return this.store;
+  }
+  runRules(rows, context) {
+    const allViolations = [];
+    for (const row of rows) {
+      const checkFn = this.checkFns.get(row.id);
+      if (!checkFn) continue;
+      const scopedFiles = filterByScope(context.files, row.scope);
+      if (scopedFiles.length === 0 && row.trigger_type !== "commit" && row.trigger_type !== "pre-commit")
+        continue;
+      const scopedCtx = {
+        ...context,
+        files: scopedFiles
+      };
+      const result = checkFn(scopedCtx);
+      if (!result.passed) {
+        allViolations.push(...result.violations);
+      }
+    }
+    return {
+      passed: allViolations.length === 0,
+      violations: allViolations
+    };
+  }
+}
+export {
+  RuleEngine
+};

package/dist/src/core/rules/rule-store.js

@@ -0,0 +1,99 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS rules (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '',
+  trigger_type TEXT NOT NULL DEFAULT 'on-demand',
+  severity TEXT NOT NULL DEFAULT 'warn',
+  scope TEXT NOT NULL DEFAULT '**/*',
+  enabled INTEGER NOT NULL DEFAULT 1,
+  builtin INTEGER NOT NULL DEFAULT 0,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+)`;
+class RuleStore {
+  constructor(db) {
+    this.db = db;
+    this.db.exec(SCHEMA);
+  }
+  upsert(rule) {
+    const now = Date.now();
+    this.db.prepare(
+      `INSERT INTO rules (id, name, description, trigger_type, severity, scope, enabled, builtin, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           name = excluded.name,
+           description = excluded.description,
+           trigger_type = excluded.trigger_type,
+           severity = excluded.severity,
+           scope = excluded.scope,
+           enabled = excluded.enabled,
+           builtin = excluded.builtin,
+           updated_at = excluded.updated_at`
+    ).run(
+      rule.id,
+      rule.name,
+      rule.description,
+      rule.trigger_type,
+      rule.severity,
+      rule.scope,
+      rule.enabled,
+      rule.builtin,
+      now,
+      now
+    );
+  }
+  getAll() {
+    return this.db.prepare("SELECT * FROM rules ORDER BY id").all();
+  }
+  getEnabled() {
+    return this.db.prepare("SELECT * FROM rules WHERE enabled = 1 ORDER BY id").all();
+  }
+  getByTrigger(trigger) {
+    return this.db.prepare(
+      "SELECT * FROM rules WHERE enabled = 1 AND trigger_type = ? ORDER BY id"
+    ).all(trigger);
+  }
+  getById(id) {
+    return this.db.prepare("SELECT * FROM rules WHERE id = ?").get(id);
+  }
+  setEnabled(id, enabled) {
+    const result = this.db.prepare("UPDATE rules SET enabled = ?, updated_at = ? WHERE id = ?").run(enabled ? 1 : 0, Date.now(), id);
+    return result.changes > 0;
+  }
+  delete(id) {
+    const result = this.db.prepare("DELETE FROM rules WHERE id = ?").run(id);
+    return result.changes > 0;
+  }
+  seedBuiltins(rules) {
+    const now = Date.now();
+    const stmt = this.db.prepare(
+      `INSERT OR IGNORE INTO rules (id, name, description, trigger_type, severity, scope, enabled, builtin, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    const tx = this.db.transaction(() => {
+      for (const rule of rules) {
+        stmt.run(
+          rule.id,
+          rule.name,
+          rule.description,
+          rule.trigger_type,
+          rule.severity,
+          rule.scope,
+          rule.enabled,
+          rule.builtin,
+          now,
+          now
+        );
+      }
+    });
+    tx();
+  }
+}
+export {
+  RuleStore
+};

package/dist/src/core/rules/types.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/core/skills/index.js

@@ -4,3 +4,24 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 export * from "./types.js";
 export * from "./skill-storage.js";
+export * from "./skill-matcher.js";
+import {
+  SkillRegistry,
+  getSkillRegistry,
+  resetSkillRegistry
+} from "./skill-registry.js";
+import { getSkillRegistry as getSkillRegistry2 } from "./skill-registry.js";
+import { matchPrompt as matchPromptFn } from "./skill-matcher.js";
+function matchPromptFromRegistry(prompt) {
+  const registry = getSkillRegistry2();
+  const rules = registry.getAllRules();
+  const { config, scoring } = registry.getMatcherConfig();
+  const mappings = registry.getDirectoryMappings();
+  return matchPromptFn(prompt, rules, config, scoring, mappings);
+}
+export {
+  SkillRegistry,
+  getSkillRegistry,
+  matchPromptFromRegistry,
+  resetSkillRegistry
+};