claude-mem-lite 2.26.1 → 2.28.2

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);
@@ -509,8 +529,9 @@ async function install() {
   }
 
   // 6. Install pre-installed resources (skills + agents)
-  log('Setting up skill/agent registry...');
-  try {
+  if (process.env.CLAUDE_MEM_SKIP_REPOS) {
+    ok('Skill/agent registry: skipped (CLAUDE_MEM_SKIP_REPOS)');
+  } else try {
     const manifestPath = join(INSTALL_DIR, 'registry', 'preinstalled.json');
     if (!existsSync(manifestPath)) {
       // For git-clone mode, check PROJECT_DIR
@@ -545,7 +566,7 @@ async function install() {
         };
 
         for (const [repoUrl, entries] of repos) {
-          const repoName = repoUrl.split('/').slice(-2).join('-');
+          const repoName = repoUrl.split('/').slice(-2).join('-').replace(/[^a-zA-Z0-9._-]/g, '_');
           const clonePath = join(managedDir, 'repos', repoName);
           let repoReady = false;
 
@@ -939,12 +960,8 @@ async function status() {
 
   // CLI
   try {
-    const cliVer = execSync('claude-mem-lite --help 2>/dev/null && echo OK', { encoding: 'utf8', timeout: 5000 });
-    if (cliVer.includes('OK')) {
-      ok('CLI: claude-mem-lite command available');
-    } else {
-      warn('CLI: command not on PATH');
-    }
+    execFileSync('claude-mem-lite', ['--help'], { encoding: 'utf8', timeout: 5000, stdio: 'pipe' });
+    ok('CLI: claude-mem-lite command available');
   } catch {
     warn('CLI: command not on PATH — run install again to create symlink');
   }
@@ -1067,7 +1084,7 @@ async function doctor() {
 
   // Check for stale processes
   try {
-    const procs = execSync('pgrep -af "chroma|claude-mem.*worker" 2>/dev/null', { encoding: 'utf8' }).trim();
+    const procs = execFileSync('pgrep', ['-af', 'chroma|claude-mem.*worker'], { encoding: 'utf8', timeout: 5000, stdio: 'pipe' }).trim();
     // Filter out the pgrep process itself (matches its own pattern)
     const real = procs.split('\n').filter(l => !l.includes('pgrep'));
     if (real.length > 0) {

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';
@@ -51,7 +52,7 @@ function out(text) {
 }
 
 function fail(text) {
-  process.stdout.write(text + '\n');
+  process.stderr.write(text + '\n');
   process.exitCode = 1;
 }
 
@@ -114,13 +115,15 @@ function cmdSearch(db, args) {
     fail(`[mem] Invalid --sort "${sort}". Use: relevance, time, importance`);
     return;
   }
+  const useOr = flags.or === true || flags.or === 'true';
 
   if (source && !['observations', 'sessions', 'prompts'].includes(source)) {
     fail(`[mem] Invalid --source "${source}". Use: observations, sessions, prompts`);
     return;
   }
 
-  const ftsQuery = sanitizeFtsQuery(query);
+  let ftsQuery = sanitizeFtsQuery(query);
+  if (ftsQuery && useOr) ftsQuery = relaxFtsQueryToOr(ftsQuery) || ftsQuery;
   if (!ftsQuery) {
     fail(`[mem] No valid search terms in "${query}"`);
     return;
@@ -164,20 +167,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 +211,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)
@@ -441,7 +451,7 @@ function searchFts(db, ftsQuery, { type, project, limit, dateFrom, dateTo, minIm
 function cmdRecent(db, args) {
   const { positional, flags } = parseArgs(args);
   const rawLimit = parseInt(positional[0], 10);
-  const limit = Math.max(1, Number.isFinite(rawLimit) ? rawLimit : 10);
+  const limit = (Number.isInteger(rawLimit) && rawLimit > 0) ? rawLimit : 10;
   const project = flags.project ? resolveProject(db, flags.project) : inferProject();
 
   const params = [];
@@ -503,7 +513,9 @@ function cmdRecall(db, args) {
   // Update access_count for recalled observations (aligned with MCP mem_recall)
   const recalledIds = rows.map(r => r.id);
   const recallPh = recalledIds.map(() => '?').join(',');
-  db.prepare(`UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id IN (${recallPh})`).run(Date.now(), ...recalledIds);
+  try {
+    db.prepare(`UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id IN (${recallPh})`).run(Date.now(), ...recalledIds);
+  } catch { /* non-critical: FTS5 trigger may fail on corrupted index */ }
 
   out(`[mem] History for ${filename} (${rows.length}):`);
   for (const r of rows) {
@@ -580,8 +592,10 @@ function cmdGet(db, args) {
   }
 
   // Update access_count + auto-boost (aligned with MCP mem_get)
-  db.prepare(`UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id IN (${placeholders})`).run(Date.now(), ...ids);
-  autoBoostIfNeeded(db, ids);
+  try {
+    db.prepare(`UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id IN (${placeholders})`).run(Date.now(), ...ids);
+    autoBoostIfNeeded(db, ids);
+  } catch { /* non-critical: FTS5 trigger may fail on corrupted index */ }
 
   const rows = db.prepare(`
     SELECT * FROM observations
@@ -672,7 +686,9 @@ function cmdTimeline(db, args) {
   }
 
   // Update access_count for anchor (aligned with MCP mem_timeline)
-  db.prepare('UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id = ?').run(Date.now(), anchorId);
+  try {
+    db.prepare('UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id = ?').run(Date.now(), anchorId);
+  } catch { /* non-critical: FTS5 trigger may fail on corrupted index */ }
 
   // Get anchor epoch
   const anchorRow = db.prepare('SELECT created_at_epoch, project FROM observations WHERE id = ?').get(anchorId);
@@ -1650,30 +1666,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;
     }
 
@@ -1760,6 +1794,7 @@ Commands:
     --offset N          Skip first N results (pagination)
     --tier T            Filter by tier (working|active|archive, observations only)
     --sort S            Sort: relevance (default), time, importance
+    --or                Use OR instead of AND between search terms
 
   recent [N]            Show N most recent observations (default 10)
     --project P         Filter by project
@@ -1831,7 +1866,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 +1876,110 @@ Commands:
 DB: ${DB_PATH}`);
 }
 
+// ─── Import (GitHub) ────────────────────────────────────────────────────────
+
+async function cmdImport(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(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 +2025,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(cmdArgs); break;
+      case 'enrich':    await cmdEnrich(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.1",
+  "version": "2.28.2",
   "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;
+}