claude-mem-lite 2.26.0 → 2.28.1

package/install.mjs

@@ -452,7 +452,7 @@ async function install() {
     ]
   };
 
-  const memPreToolUse = {
+  const memPreToolRecall = {
     matcher: 'Edit|Write|NotebookEdit',
     hooks: [
       {
@@ -463,10 +463,30 @@ async function install() {
     ]
   };
 
+  const memPreSkillBridge = {
+    matcher: 'Skill',
+    hooks: [
+      {
+        type: 'command',
+        command: `node "${join(SCRIPTS_PATH, 'pre-skill-bridge.js')}"`,
+        timeout: 3
+      }
+    ]
+  };
+
   // Filter out existing mem hooks, then append fresh ones
-  for (const [event, config] of [['PreToolUse', memPreToolUse], ['PostToolUse', memPostToolUse], ['SessionStart', memSessionStart], ['Stop', memStop], ['UserPromptSubmit', memUserPrompt]]) {
+  // PreToolUse has two separate matchers, so we register both
+  const hookConfigs = {
+    PreToolUse: [memPreToolRecall, memPreSkillBridge],
+    PostToolUse: [memPostToolUse],
+    SessionStart: [memSessionStart],
+    Stop: [memStop],
+    UserPromptSubmit: [memUserPrompt],
+  };
+
+  for (const [event, configs] of Object.entries(hookConfigs)) {
     const existing = Array.isArray(settings.hooks[event]) ? settings.hooks[event].filter(cfg => !isMemHook(cfg)) : [];
-    settings.hooks[event] = [...existing, config];
+    settings.hooks[event] = [...existing, ...configs];
   }
 
   writeSettings(settings);

package/mem-cli.mjs

@@ -2,6 +2,7 @@
 // claude-mem-lite CLI — lightweight command layer for direct memory access
 // No MCP SDK or heavy deps — only imports schema.mjs and utils.mjs
 
+import { homedir } from 'os';
 import { ensureDb, DB_PATH, REGISTRY_DB_PATH, checkFTSIntegrity, rebuildFTS } from './schema.mjs';
 import { sanitizeFtsQuery, relaxFtsQueryToOr, truncate, typeIcon, inferProject, jaccardSimilarity, computeMinHash, estimateJaccardFromMinHash, scrubSecrets, cjkBigrams, isoWeekKey, COMPRESSED_PENDING_PURGE, OBS_BM25, SESS_BM25, TYPE_DECAY_CASE, TYPE_QUALITY_CASE, DEFAULT_DECAY_HALF_LIFE_MS, getCurrentBranch } from './utils.mjs';
 import { resolveProject } from './project-utils.mjs';
@@ -164,20 +165,6 @@ function cmdSearch(db, args) {
         LIMIT ?
       `).all(...typeParams);
     }
-    // Tier post-filter
-    if (tier && obsRows.length > 0) {
-      const rowIds = obsRows.map(r => r.id);
-      const ph = rowIds.map(() => '?').join(',');
-      const fullRows = db.prepare(
-        `SELECT id, compressed_into, superseded_at, memory_session_id, project, importance, last_accessed_at, created_at_epoch, type FROM observations WHERE id IN (${ph})`
-      ).all(...rowIds);
-      const rowMap = new Map(fullRows.map(r => [r.id, r]));
-      const tierCtx = { now: Date.now(), currentProject: project || inferProject(), currentSessionId: '' };
-      obsRows = obsRows.filter(r => {
-        const full = rowMap.get(r.id);
-        return full && computeTier(full, tierCtx) === tier;
-      });
-    }
     for (const r of obsRows) results.push({ ...r, _source: 'obs', score: r.score ?? 0 });
 
     // Concept co-occurrence + PRF expansion (aligned with MCP searchObservations)
@@ -222,6 +209,27 @@ function cmdSearch(db, args) {
         }
       }
     }
+
+    // Tier post-filter — applied to ALL obs results (initial + expansion + PRF)
+    if (tier) {
+      const obsInResults = results.filter(r => r._source === 'obs');
+      if (obsInResults.length > 0) {
+        const obsIds = obsInResults.map(r => r.id);
+        const ph = obsIds.map(() => '?').join(',');
+        const fullRows = db.prepare(
+          `SELECT id, compressed_into, superseded_at, memory_session_id, project, importance, last_accessed_at, created_at_epoch, type FROM observations WHERE id IN (${ph})`
+        ).all(...obsIds);
+        const rowMap = new Map(fullRows.map(r => [r.id, r]));
+        const tierCtx = { now: Date.now(), currentProject: project || inferProject(), currentSessionId: '' };
+        const allowedIds = new Set();
+        for (const [id, full] of rowMap) {
+          if (computeTier(full, tierCtx) === tier) allowedIds.add(id);
+        }
+        for (let i = results.length - 1; i >= 0; i--) {
+          if (results[i]._source === 'obs' && !allowedIds.has(results[i].id)) results.splice(i, 1);
+        }
+      }
+    }
   }
 
   // Search sessions (aligned with MCP mem_search)
@@ -1650,30 +1658,48 @@ function cmdRegistry(_memDb, args) {
       results = results.slice(0, 5);
       if (results.length === 0) { out(`[mem] No matching resources for: "${query}"`); return; }
       out(`[mem] ${results.length} resource(s) for "${query}":`);
+      const home = homedir();
       for (const r of results) {
         const badge = r.quality_tier === 'installed' ? '[✓]' : r.quality_tier === 'verified' ? '[★]' : '[○]';
         const categoryLabel = r.category ? ` [${r.category}]` : '';
-        const howToUse = r.type === 'skill'
-          ? (r.invocation_name ? `skill="${r.invocation_name}"` : r.name)
-          : `subagent_type="${r.invocation_name || r.name}"`;
-        out(`  ${badge} ${r.type === 'skill' ? 'S' : 'A'} ${r.name}${categoryLabel} — ${truncate(r.capability_summary || '', 80)} | Use: ${howToUse}`);
+        const isManaged = r.local_path && r.local_path.includes('/.claude-mem-lite/managed/');
+        const portablePath = isManaged && r.local_path.startsWith(home) ? '~' + r.local_path.slice(home.length) : (r.local_path || '');
+        let howToUse;
+        if (isManaged) {
+          const resolvedPath = portablePath.endsWith('.md') ? portablePath : `${portablePath}/SKILL.md`;
+          howToUse = `Read("${resolvedPath}") or mem_use(name="${r.name}"${r.type === 'agent' ? ', type="agent"' : ''})`;
+        } else if (r.invocation_name) {
+          howToUse = r.type === 'skill'
+            ? `Skill("${r.invocation_name}")`
+            : `Agent(subagent_type="${r.invocation_name}")`;
+        } else {
+          howToUse = `mem_use(name="${r.name}"${r.type === 'agent' ? ', type="agent"' : ''})`;
+        }
+        const pathLine = portablePath ? `\n    Path: ${portablePath}` : '';
+        out(`  ${badge} ${r.type === 'skill' ? 'S' : 'A'} ${r.name}${categoryLabel} — ${truncate(r.capability_summary || '', 80)}${pathLine}\n    Use: ${howToUse}`);
       }
       return;
     }
 
     if (action === 'list') {
       const typeFilter = flags.type;
+      const rawLimit = parseInt(flags.limit, 10);
+      const listLimit = Number.isInteger(rawLimit) && rawLimit > 0 ? rawLimit : 20;
       const where = typeFilter ? 'WHERE type = ? AND status = ?' : 'WHERE status = ?';
       const params = typeFilter ? [typeFilter, 'active'] : ['active'];
-      const resources = rdb.prepare(`
+      const allResources = rdb.prepare(`
         SELECT name, type, invocation_name, recommend_count, adopt_count, capability_summary
-        FROM resources ${where} ORDER BY type, name
+        FROM resources ${where} ORDER BY adopt_count DESC, recommend_count DESC, type, name
       `).all(...params);
-      if (resources.length === 0) { out('[mem] No resources found.'); return; }
-      out(`[mem] Resources (${resources.length}):`);
+      if (allResources.length === 0) { out('[mem] No resources found.'); return; }
+      const resources = allResources.slice(0, listLimit);
+      out(`[mem] Resources (showing ${resources.length} of ${allResources.length}):`);
       for (const r of resources) {
         out(`  ${r.type === 'skill' ? 'S' : 'A'} ${r.name}${r.invocation_name ? ` (${r.invocation_name})` : ''} — rec:${r.recommend_count} adopt:${r.adopt_count} — ${truncate(r.capability_summary || '', 50)}`);
       }
+      if (allResources.length > listLimit) {
+        out(`[mem] Use --limit N to see more, or "registry search <query>" to find specific resources.`);
+      }
       return;
     }
 
@@ -1831,7 +1857,7 @@ Commands:
     --limit N           Max entries per tier (default 5)
 
   registry <action>     Manage tool resource registry
-    list                List all resources [--type skill|agent]
+    list                List resources [--type skill|agent] [--limit N] (default 20)
     stats               Registry statistics
     search <query>      Search resources [--type skill|agent] [--category C] [--quality Q]
     import              Import resource --name N --resource-type T [--repo-url U] [--local-path P] [--use-cases U]
@@ -1841,6 +1867,110 @@ Commands:
 DB: ${DB_PATH}`);
 }
 
+// ─── Import (GitHub) ────────────────────────────────────────────────────────
+
+async function cmdImport(db, argv) {
+  const { positional, flags } = parseArgs(argv);
+  const url = positional[0];
+
+  if (!url) { fail('[mem] Usage: claude-mem-lite import <github-url> [--enrich]'); return; }
+
+  let rdb;
+  try {
+    rdb = ensureRegistryDb(REGISTRY_DB_PATH);
+    rdb.pragma('busy_timeout = 3000');
+  } catch (e) {
+    fail(`[mem] Registry DB error: ${e.message}`);
+    return;
+  }
+
+  try {
+    const { importFromGitHub } = await import('./registry-importer.mjs');
+    out(`[mem] Importing from ${url}...`);
+    const results = await importFromGitHub(rdb, url);
+
+    if (results.length === 0) {
+      out('[mem] No skills/agents found in this repository.');
+      return;
+    }
+
+    out(`[mem] Imported ${results.length} resource(s):`);
+    for (const r of results) {
+      out(`  ${r.type === 'skill' ? 'S' : 'A'} ${r.name} (id=${r.id})`);
+    }
+
+    if (flags.enrich) {
+      out('[mem] Running LLM enrichment...');
+      const { enrichResource } = await import('./registry-enricher.mjs');
+      let enriched = 0;
+      for (const r of results) {
+        const row = rdb.prepare('SELECT local_path FROM resources WHERE id = ?').get(r.id);
+        if (!row?.local_path) continue;
+        try {
+          const content = readFileSync(row.local_path, 'utf8');
+          const ok = await enrichResource(rdb, r.name, r.type, content);
+          if (ok) enriched++;
+        } catch {}
+      }
+      out(`[mem] Enriched ${enriched}/${results.length} resources.`);
+    }
+  } catch (e) {
+    fail(`[mem] Import failed: ${e.message}`);
+  } finally {
+    try { rdb.close(); } catch {}
+  }
+}
+
+// ─── Enrich ─────────────────────────────────────────────────────────────────
+
+async function cmdEnrich(db, argv) {
+  const { positional, flags } = parseArgs(argv);
+  const name = positional[0];
+
+  let rdb;
+  try {
+    rdb = ensureRegistryDb(REGISTRY_DB_PATH);
+    rdb.pragma('busy_timeout = 3000');
+  } catch (e) {
+    fail(`[mem] Registry DB error: ${e.message}`);
+    return;
+  }
+
+  try {
+    const { enrichResource } = await import('./registry-enricher.mjs');
+
+    if (flags.all) {
+      const rows = rdb.prepare("SELECT name, type, local_path FROM resources WHERE status = 'active' AND (enrichment_status IS NULL OR enrichment_status = 'failed')").all();
+      if (rows.length === 0) { out('[mem] All resources already enriched.'); return; }
+      out(`[mem] Enriching ${rows.length} resources...`);
+      let ok = 0, failCount = 0;
+      for (const r of rows) {
+        if (!r.local_path) { failCount++; continue; }
+        try {
+          const content = readFileSync(r.local_path, 'utf8');
+          const success = await enrichResource(rdb, r.name, r.type, content);
+          if (success) ok++; else failCount++;
+          if (!flags.batch) await new Promise(resolve => setTimeout(resolve, 500));
+        } catch { failCount++; }
+      }
+      out(`[mem] Done: ${ok} enriched, ${failCount} failed.`);
+    } else if (name) {
+      const row = rdb.prepare("SELECT name, type, local_path FROM resources WHERE name = ? AND status = 'active'").get(name);
+      if (!row) { fail(`[mem] Resource not found: ${name}`); return; }
+      if (!row.local_path) { fail(`[mem] No local_path for ${name}`); return; }
+      const content = readFileSync(row.local_path, 'utf8');
+      const success = await enrichResource(rdb, row.name, row.type, content);
+      out(success ? `[mem] Enriched: ${name}` : `[mem] Enrichment failed for ${name}`);
+    } else {
+      fail('[mem] Usage: claude-mem-lite enrich <name> OR claude-mem-lite enrich --all [--batch]');
+    }
+  } catch (e) {
+    fail(`[mem] Enrich error: ${e.message}`);
+  } finally {
+    try { rdb.close(); } catch {}
+  }
+}
+
 // ─── Main Entry Point ────────────────────────────────────────────────────────
 
 export async function run(argv) {
@@ -1886,6 +2016,8 @@ export async function run(argv) {
       case 'context':   cmdContext(db, cmdArgs); break;
       case 'browse':    cmdBrowse(db, cmdArgs); break;
       case 'registry':  cmdRegistry(db, cmdArgs); break;
+      case 'import':    await cmdImport(db, cmdArgs); break;
+      case 'enrich':    await cmdEnrich(db, cmdArgs); break;
       default:
         out(`[mem] Unknown command: ${cmd}`);
         out('[mem] Run "claude-mem-lite help" for usage');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.26.0",
+  "version": "2.28.1",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "engines": {
@@ -40,6 +40,9 @@
     "registry-retriever.mjs",
     "registry-indexer.mjs",
     "registry-scanner.mjs",
+    "registry-github.mjs",
+    "registry-importer.mjs",
+    "registry-enricher.mjs",
     "resource-discovery.mjs",
     "install.mjs",
     "install-metadata.mjs",
@@ -73,6 +76,7 @@
     "scripts/post-tool-use.sh",
     "scripts/user-prompt-search.js",
     "scripts/pre-tool-recall.js",
+    "scripts/pre-skill-bridge.js",
     "scripts/prompt-search-utils.mjs",
     ".mcp.json",
     ".claude-plugin/plugin.json",

package/registry-enricher.mjs

@@ -0,0 +1,101 @@
+// claude-mem-lite: LLM enrichment for registry resources (Stage 2)
+// Sends resource content to Haiku for semantic metadata generation
+// Graceful degradation: failure preserves existing data
+
+import { callHaikuJSON } from './haiku-client.mjs';
+import { truncate, debugCatch } from './utils.mjs';
+
+/**
+ * Build the enrichment prompt for Haiku.
+ * @param {string} name Resource name
+ * @param {string} content SKILL.md/AGENT.md content
+ * @param {object} existingMeta Existing metadata from DB
+ * @returns {string} Prompt string
+ */
+export function buildEnrichPrompt(name, content, existingMeta) {
+  const truncated = truncate(content, 3000);
+  const existing = existingMeta.intent_tags ? `\n<existing-metadata>\ncurrent_tags: ${existingMeta.intent_tags}\n</existing-metadata>` : '';
+
+  return `You are a tool classification expert. Analyze this Claude Code skill and extract structured metadata.
+
+<skill-name>${name}</skill-name>
+<skill-content>
+${truncated}
+</skill-content>
+${existing}
+Return JSON only:
+{"capability_summary":"One sentence (<80 chars)","intent_tags":"comma-separated intents","domain_tags":"comma-separated domains","trigger_patterns":"when to recommend","use_cases":"comma-separated scenarios","tech_stack":"comma-separated tech","quality_assessment":{"has_clear_instructions":true,"has_examples":false,"specificity":"high","estimated_utility":"high"}}`;
+}
+
+/**
+ * Apply LLM enrichment results to a resource.
+ * Only fills empty fields — never overwrites existing non-empty data.
+ * @param {Database} db Registry database
+ * @param {string} name Resource name
+ * @param {string} type Resource type
+ * @param {object} enrichResult LLM result JSON
+ */
+export function applyEnrichment(db, name, type, enrichResult) {
+  const row = db.prepare('SELECT * FROM resources WHERE name = ? AND type = ?').get(name, type);
+  if (!row) return;
+
+  const updates = [];
+  const params = [];
+
+  // Only fill empty fields
+  const fields = ['capability_summary', 'intent_tags', 'domain_tags', 'trigger_patterns', 'use_cases', 'tech_stack'];
+  for (const f of fields) {
+    if ((!row[f] || row[f].trim() === '') && enrichResult[f]) {
+      updates.push(`${f} = ?`);
+      params.push(enrichResult[f]);
+    }
+  }
+
+  // Always update enrichment status
+  updates.push("enrichment_status = 'done'");
+  updates.push('enriched_at = ?');
+  params.push(Date.now());
+
+  // Quality tier upgrade based on assessment
+  const qa = enrichResult.quality_assessment;
+  if (qa && row.quality_tier === 'community') {
+    if (qa.has_clear_instructions && (qa.specificity === 'high' || qa.specificity === 'medium')) {
+      updates.push("quality_tier = 'verified'");
+    }
+  }
+
+  params.push(name, type);
+  db.prepare(`UPDATE resources SET ${updates.join(', ')} WHERE name = ? AND type = ?`).run(...params);
+}
+
+/**
+ * Enrich a single resource via Haiku LLM.
+ * @param {Database} db Registry database
+ * @param {string} name Resource name
+ * @param {string} type Resource type
+ * @param {string} content SKILL.md/AGENT.md content
+ * @returns {Promise<boolean>} true if enriched successfully
+ */
+export async function enrichResource(db, name, type, content) {
+  const existing = db.prepare('SELECT intent_tags, capability_summary FROM resources WHERE name = ? AND type = ?').get(name, type);
+  if (!existing) return false;
+
+  db.prepare("UPDATE resources SET enrichment_status = 'pending' WHERE name = ? AND type = ?").run(name, type);
+
+  try {
+    const prompt = buildEnrichPrompt(name, content, existing);
+    const result = await callHaikuJSON(prompt, { timeout: 15000, maxTokens: 500 });
+
+    if (!result || !result.capability_summary) {
+      db.prepare("UPDATE resources SET enrichment_status = 'failed' WHERE name = ? AND type = ?").run(name, type);
+      return false;
+    }
+
+    applyEnrichment(db, name, type, result);
+    return true;
+  } catch (e) {
+    debugCatch(e, 'enricher');
+    db.prepare("UPDATE resources SET enrichment_status = 'failed' WHERE name = ? AND type = ?").run(name, type);
+    return false;
+  }
+}

package/registry-github.mjs

@@ -0,0 +1,54 @@
+// claude-mem-lite: GitHub API helpers for smart import
+// Pure functions for URL parsing and API URL construction
+// Actual HTTP calls are in registry-importer.mjs
+
+/**
+ * Parse a GitHub URL into owner, repo, branch, path.
+ * @param {string} url GitHub URL
+ * @returns {{ owner: string, repo: string, branch: string, path: string } | null}
+ */
+export function parseGitHubUrl(url) {
+  if (!url || typeof url !== 'string') return null;
+  const match = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?\/?(?:\/tree\/([^/]+)(\/.*)?)?$/);
+  if (!match) return null;
+  const [, owner, repo, branch, pathRaw] = match;
+  return {
+    owner,
+    repo,
+    branch: branch || 'main',
+    path: pathRaw ? pathRaw.replace(/^\//, '') : '',
+  };
+}
+
+/**
+ * Build GitHub API tree URL (recursive).
+ */
+export function buildTreeUrl(owner, repo, branch) {
+  return `https://api.github.com/repos/${owner}/${repo}/git/trees/${branch}?recursive=1`;
+}
+
+/**
+ * Build raw content URL for a file.
+ */
+export function buildContentUrl(owner, repo, branch, path) {
+  return `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${path}`;
+}
+
+/**
+ * Build GitHub API repo metadata URL.
+ */
+export function buildRepoUrl(owner, repo) {
+  return `https://api.github.com/repos/${owner}/${repo}`;
+}
+
+/**
+ * Build headers for GitHub API requests.
+ * Uses GITHUB_TOKEN env var if available.
+ * @returns {Record<string, string>}
+ */
+export function buildHeaders() {
+  const headers = { 'User-Agent': 'claude-mem-lite', Accept: 'application/vnd.github.v3+json' };
+  const token = process.env.GITHUB_TOKEN;
+  if (token) headers.Authorization = `token ${token}`;
+  return headers;
+}