@stackmemoryai/stackmemory 1.10.5 → 1.12.0

package/dist/src/core/cross-search/cross-project-search.js

@@ -0,0 +1,269 @@
+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 {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  readdirSync
+} from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { logger } from "../monitoring/logger.js";
+function sanitizeFtsQuery(query) {
+  const wantsPrefix = query.trimEnd().endsWith("*");
+  const cleaned = query.replace(/['"(){}[\]^~*\\,]/g, " ").replace(/\b(AND|OR|NOT|NEAR)\b/gi, "").trim();
+  const terms = cleaned.split(/\s+/).filter((t) => t.length > 0);
+  if (terms.length === 0) return '""';
+  const quoted = terms.map((t) => `"${t}"`);
+  if (wantsPrefix) {
+    quoted[quoted.length - 1] = quoted[quoted.length - 1] + "*";
+  }
+  return quoted.join(" ");
+}
+class CrossProjectSearch {
+  registryPath;
+  constructor(registryDir) {
+    const dir = registryDir || join(homedir(), ".stackmemory");
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    this.registryPath = join(dir, "projects.json");
+  }
+  // --- Project Registry CRUD ---
+  loadRegistry() {
+    if (!existsSync(this.registryPath)) {
+      return { projects: [] };
+    }
+    try {
+      const raw = readFileSync(this.registryPath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      logger.warn("Failed to parse projects.json, returning empty registry");
+      return { projects: [] };
+    }
+  }
+  saveRegistry(registry) {
+    writeFileSync(this.registryPath, JSON.stringify(registry, null, 2));
+  }
+  registerProject(entry) {
+    const registry = this.loadRegistry();
+    const idx = registry.projects.findIndex(
+      (p) => p.path === entry.path || p.dbPath === entry.dbPath
+    );
+    if (idx >= 0) {
+      registry.projects[idx] = entry;
+    } else {
+      registry.projects.push(entry);
+    }
+    this.saveRegistry(registry);
+  }
+  unregisterProject(pathOrName) {
+    const registry = this.loadRegistry();
+    const before = registry.projects.length;
+    registry.projects = registry.projects.filter(
+      (p) => p.path !== pathOrName && p.name !== pathOrName
+    );
+    if (registry.projects.length < before) {
+      this.saveRegistry(registry);
+      return true;
+    }
+    return false;
+  }
+  listProjects() {
+    return this.loadRegistry().projects;
+  }
+  /**
+   * Auto-discover projects by scanning common directories for .stackmemory/context.db
+   */
+  discoverProjects(basePaths) {
+    const paths = basePaths || [
+      join(homedir(), "Dev"),
+      join(homedir(), "dev"),
+      join(homedir(), "Projects"),
+      join(homedir(), "projects"),
+      join(homedir(), "Work"),
+      join(homedir(), "work"),
+      join(homedir(), "code"),
+      join(homedir(), "Code")
+    ];
+    const homeDb = join(homedir(), ".stackmemory", "context.db");
+    const discovered = [];
+    if (existsSync(homeDb)) {
+      discovered.push({
+        name: "global",
+        path: homedir(),
+        dbPath: homeDb,
+        lastAccessed: Date.now()
+      });
+    }
+    for (const basePath of paths) {
+      if (!existsSync(basePath)) continue;
+      try {
+        this.scanForDatabases(basePath, 0, 3, discovered);
+      } catch {
+      }
+    }
+    const registry = this.loadRegistry();
+    for (const entry of discovered) {
+      const existing = registry.projects.find((p) => p.dbPath === entry.dbPath);
+      if (!existing) {
+        registry.projects.push(entry);
+      }
+    }
+    this.saveRegistry(registry);
+    return discovered;
+  }
+  scanForDatabases(dir, depth, maxDepth, results) {
+    if (depth > maxDepth) return;
+    const dbPath = join(dir, ".stackmemory", "context.db");
+    if (existsSync(dbPath)) {
+      const name = dir.split("/").pop() || dir;
+      results.push({
+        name,
+        path: dir,
+        dbPath,
+        lastAccessed: Date.now()
+      });
+      return;
+    }
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules" && entry.name !== "dist" && entry.name !== "build") {
+          this.scanForDatabases(
+            join(dir, entry.name),
+            depth + 1,
+            maxDepth,
+            results
+          );
+        }
+      }
+    } catch {
+    }
+  }
+  // --- Cross-Project Search ---
+  /**
+   * Search across all registered project databases using FTS5/BM25.
+   * Opens read-only connections. Skips missing/locked databases gracefully.
+   */
+  async search(options) {
+    const { query, limit = 20, excludeProject } = options;
+    const registry = this.loadRegistry();
+    if (registry.projects.length === 0) {
+      return [];
+    }
+    const allResults = [];
+    const perDbLimit = Math.max(limit, 10);
+    for (const project of registry.projects) {
+      if (excludeProject && project.name === excludeProject) continue;
+      if (!existsSync(project.dbPath)) {
+        logger.debug(`Skipping missing database: ${project.dbPath}`);
+        continue;
+      }
+      try {
+        const results = this.searchSingleDb(project, query, perDbLimit);
+        allResults.push(...results);
+      } catch (error) {
+        logger.debug(
+          `Skipping database ${project.dbPath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    allResults.sort((a, b) => b.score - a.score);
+    return allResults.slice(0, limit);
+  }
+  /**
+   * Search a single project database (read-only connection).
+   */
+  searchSingleDb(project, query, limit) {
+    let db = null;
+    try {
+      db = new Database(project.dbPath, {
+        readonly: true,
+        fileMustExist: true
+      });
+      const hasFts = db.prepare(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='frames_fts'"
+      ).get();
+      if (hasFts) {
+        return this.searchFts(db, project, query, limit);
+      } else {
+        return this.searchLike(db, project, query, limit);
+      }
+    } finally {
+      if (db) {
+        try {
+          db.close();
+        } catch {
+        }
+      }
+    }
+  }
+  searchFts(db, project, query, limit) {
+    const sanitized = sanitizeFtsQuery(query);
+    const sql = `
+      SELECT f.frame_id, f.name, f.type, f.state, f.digest_text, f.created_at,
+             -bm25(frames_fts, 10.0, 5.0, 2.0, 1.0) as score
+      FROM frames_fts fts
+      JOIN frames f ON f.rowid = fts.rowid
+      WHERE frames_fts MATCH ?
+      ORDER BY score DESC
+      LIMIT ?
+    `;
+    const rows = db.prepare(sql).all(sanitized, limit);
+    return rows.map((row) => ({
+      projectName: project.name,
+      projectPath: project.path,
+      frameId: row.frame_id,
+      name: row.name,
+      type: row.type,
+      state: row.state,
+      digestText: row.digest_text,
+      score: row.score,
+      createdAt: row.created_at
+    }));
+  }
+  searchLike(db, project, query, limit) {
+    const likeParam = `%${query}%`;
+    const sql = `
+      SELECT frame_id, name, type, state, digest_text, created_at,
+        CASE
+          WHEN name LIKE ? THEN 1.0
+          WHEN digest_text LIKE ? THEN 0.8
+          WHEN inputs LIKE ? THEN 0.6
+          ELSE 0.5
+        END as score
+      FROM frames
+      WHERE (name LIKE ? OR digest_text LIKE ? OR inputs LIKE ?)
+      ORDER BY score DESC
+      LIMIT ?
+    `;
+    const rows = db.prepare(sql).all(
+      likeParam,
+      likeParam,
+      likeParam,
+      likeParam,
+      likeParam,
+      likeParam,
+      limit
+    );
+    return rows.map((row) => ({
+      projectName: project.name,
+      projectPath: project.path,
+      frameId: row.frame_id,
+      name: row.name,
+      type: row.type,
+      state: row.state,
+      digestText: row.digest_text,
+      score: row.score,
+      createdAt: row.created_at
+    }));
+  }
+}
+export {
+  CrossProjectSearch
+};

package/dist/src/core/{merge → cross-search}/index.js

@@ -2,7 +2,9 @@ import { fileURLToPath as __fileURLToPath } from 'url';
 import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
-export * from "./types.js";
-export * from "./conflict-detector.js";
-export * from "./stack-diff.js";
-export * from "./resolution-engine.js";
+import {
+  CrossProjectSearch
+} from "./cross-project-search.js";
+export {
+  CrossProjectSearch
+};

package/dist/src/core/database/sqlite-adapter.js

@@ -1530,89 +1530,6 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
     }
     return Buffer.from(JSON.stringify(data, null, 2));
   }
-  /**
-   * Get recent frames from other run_ids within the same project.
-   * Used by team tools to read cross-agent context.
-   */
-  async getRecentFramesExcludingRun(projectId, excludeRunId, opts) {
-    if (!this.db)
-      throw new DatabaseError(
-        "Database not connected",
-        ErrorCode.DB_CONNECTION_FAILED
-      );
-    const limit = opts?.limit ?? 10;
-    const params = [projectId, excludeRunId];
-    let whereExtra = "";
-    if (opts?.since) {
-      whereExtra += " AND created_at > ?";
-      params.push(Math.floor(opts.since / 1e3));
-    }
-    if (opts?.types && opts.types.length > 0) {
-      const placeholders = opts.types.map(() => "?").join(",");
-      whereExtra += ` AND type IN (${placeholders})`;
-      params.push(...opts.types);
-    }
-    params.push(limit);
-    const rows = this.db.prepare(
-      `SELECT * FROM frames
-         WHERE project_id = ? AND run_id != ?${whereExtra}
-         ORDER BY created_at DESC
-         LIMIT ?`
-    ).all(...params);
-    const frameIds = rows.map((r) => r.frame_id);
-    const anchorsByFrame = /* @__PURE__ */ new Map();
-    if (frameIds.length > 0) {
-      const placeholders = frameIds.map(() => "?").join(",");
-      const anchorRows = this.db.prepare(
-        `SELECT * FROM anchors WHERE frame_id IN (${placeholders})
-           ORDER BY priority DESC, created_at ASC`
-      ).all(...frameIds);
-      for (const row of anchorRows) {
-        const list = anchorsByFrame.get(row.frame_id) || [];
-        list.push({ ...row, metadata: JSON.parse(row.metadata || "{}") });
-        anchorsByFrame.set(row.frame_id, list);
-      }
-    }
-    return rows.map((row) => ({
-      ...row,
-      inputs: JSON.parse(row.inputs || "{}"),
-      outputs: JSON.parse(row.outputs || "{}"),
-      digest_json: JSON.parse(row.digest_json || "{}"),
-      anchors: anchorsByFrame.get(row.frame_id) || []
-    }));
-  }
-  /**
-   * Get anchors explicitly shared for team visibility.
-   * Finds anchors where metadata contains `"shared":true`.
-   */
-  async getSharedAnchors(projectId, opts) {
-    if (!this.db)
-      throw new DatabaseError(
-        "Database not connected",
-        ErrorCode.DB_CONNECTION_FAILED
-      );
-    const limit = opts?.limit ?? 20;
-    const params = [projectId];
-    let whereExtra = "";
-    if (opts?.since) {
-      whereExtra += " AND a.created_at > ?";
-      params.push(Math.floor(opts.since / 1e3));
-    }
-    params.push(limit);
-    const rows = this.db.prepare(
-      `SELECT a.*, f.name as frame_name, f.run_id
-         FROM anchors a
-         JOIN frames f ON a.frame_id = f.frame_id
-         WHERE f.project_id = ?
-           AND a.metadata LIKE '%"shared":true%'${whereExtra}
-         ORDER BY a.priority DESC, a.created_at DESC
-         LIMIT ?`
-    ).all(...params);
-    return rows.map((row) => ({
-      ...row,
-      metadata: JSON.parse(row.metadata || "{}")
-    }));
-  }
   async importData(data, format, options) {
     if (!this.db)
       throw new DatabaseError(

package/dist/src/core/extensions/provider-adapter.js

@@ -387,6 +387,11 @@ function createProvider(id, config) {
         apiKey: config.apiKey,
         baseUrl: config.baseUrl || "https://openrouter.ai/api"
       });
+    case "moonshot":
+      return new GPTAdapter({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl || "https://api.moonshot.ai/v1"
+      });
     default:
       throw new Error(`No adapter for provider: ${id}`);
   }

package/dist/src/core/models/model-router.js

@@ -35,7 +35,10 @@ const MODEL_TOKEN_LIMITS = {
   // Cerebras
   "llama-4-scout-17b-16e-instruct": 131072,
   // DeepInfra
-  "THUDM/glm-4-9b-chat": 128e3
+  "THUDM/glm-4-9b-chat": 128e3,
+  // Moonshot (Kimi)
+  "kimi-k2.6": 256e3,
+  "kimi-k2.5": 256e3
 };
 const DEFAULT_MODEL_TOKEN_LIMIT = 2e5;
 function getModelTokenLimit(model) {
@@ -91,6 +94,12 @@ const DEFAULT_CONFIG = {
       baseUrl: "https://openrouter.ai/api",
       apiKeyEnv: "OPENROUTER_API_KEY"
     },
+    moonshot: {
+      provider: "moonshot",
+      model: "kimi-k2.6",
+      baseUrl: "https://api.moonshot.ai/v1",
+      apiKeyEnv: "MOONSHOT_API_KEY"
+    },
     "anthropic-batch": {
       provider: "anthropic-batch",
       model: "claude-sonnet-4-5-20250929",
@@ -235,8 +244,19 @@ const OPTIMAL_ROUTING = {
     apiKeyEnv: "ANTHROPIC_API_KEY"
   }
 };
-const FALLBACK_CHAIN = ["deepinfra", "cerebras", "anthropic"];
+const FALLBACK_CHAIN = [
+  "moonshot",
+  "deepinfra",
+  "cerebras",
+  "anthropic"
+];
 const CHEAP_PROVIDERS = [
+  {
+    provider: "moonshot",
+    model: "kimi-k2.6",
+    apiKeyEnv: "MOONSHOT_API_KEY",
+    baseUrl: "https://api.moonshot.ai/v1"
+  },
   {
     provider: "openrouter",
     model: "meta-llama/llama-4-scout",

package/dist/src/core/monitoring/logger.js

@@ -76,6 +76,7 @@ class Logger {
   fileLoggingDisabledNotified = false;
   constructor() {
     const envLevel = process.env["STACKMEMORY_LOG_LEVEL"]?.toUpperCase();
+    const jsonCliMode = !envLevel && process.argv.includes("--json");
     switch (envLevel) {
       case "ERROR":
         this.logLevel = 0 /* ERROR */;
@@ -87,7 +88,7 @@ class Logger {
         this.logLevel = 3 /* DEBUG */;
         break;
       default:
-        this.logLevel = 2 /* INFO */;
+        this.logLevel = jsonCliMode ? 0 /* ERROR */ : 2 /* INFO */;
     }
     if (this.logLevel === 3 /* DEBUG */ || process.env["STACKMEMORY_LOG_FILE"]) {
       this.logFile = process.env["STACKMEMORY_LOG_FILE"] || path.join(