@ijfw/memory-server 1.3.0

package/src/importers/discover.js

@@ -0,0 +1,235 @@
+// --- project discovery for `ijfw import <tool> --all` ---
+//
+// Given a source memory store (claude-mem SQLite), this module answers:
+//   "Which projects does the store reference, and where do they live on disk?"
+//
+// Sources consulted:
+//   1. claude-mem's own `project` column (authoritative for what to import)
+//   2. ~/.claude/projects/ (Claude Code's project directory -- path-encoded)
+//   3. Common dev parents: ~/dev, ~/Code, ~/projects, ~/repos, ~/work, ~/src
+//
+// Output shape (from buildProjectPlan):
+//   {
+//     source: '/path/to/claude-mem.db',
+//     matched:    [{ project, path, entryCount, confidence, evidence }],
+//     ambiguous:  [{ project, candidates: [{path, confidence, evidence}], entryCount }],
+//     unmatched:  [{ project, entryCount }],
+//   }
+
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { homedir } from 'node:os';
+
+const DEV_PARENTS = ['dev', 'Code', 'code', 'projects', 'repos', 'work', 'src'];
+
+// Decode Claude Code's path-encoded project directory name back to an absolute
+// path. Example: "-Users-seandonahoe-dev-pip" -> "/Users/seandonahoe/dev/pip".
+// Encoding replaces `/` with `-`. Leading `-` becomes leading `/`.
+// Caveat: directories with literal `-` in their name become ambiguous on
+// decode; we verify by checking whether the decoded path exists.
+export function decodeClaudeProjectDir(name) {
+  if (!name || typeof name !== 'string') return null;
+  // Leading `-` -> leading `/`. Other `-` -> `/`.
+  // We return the most likely decoding (all `-` as `/`). Caller verifies.
+  const decoded = '/' + name.replace(/^-+/, '').replace(/-/g, '/');
+  return decoded;
+}
+
+// Returns a flat list of absolute project paths Claude Code has worked in.
+// Only includes paths that still exist on disk.
+export function discoverKnownProjectPaths({ home = homedir() } = {}) {
+  const projectsDir = join(home, '.claude', 'projects');
+  if (!existsSync(projectsDir)) return [];
+  let entries;
+  try { entries = readdirSync(projectsDir); } catch { return []; }
+  const paths = [];
+  for (const name of entries) {
+    const decoded = decodeClaudeProjectDir(name);
+    if (!decoded) continue;
+    try {
+      if (existsSync(decoded) && statSync(decoded).isDirectory()) {
+        paths.push(decoded);
+      }
+    } catch { /* skip */ }
+  }
+  return paths;
+}
+
+// Returns paths like ~/dev/*, ~/Code/*, etc. -- immediate children of common
+// dev parents that exist on disk. Helps catch projects Claude Code hasn't
+// touched yet.
+export function discoverDevParentPaths({ home = homedir() } = {}) {
+  const paths = [];
+  for (const parent of DEV_PARENTS) {
+    const dir = join(home, parent);
+    if (!existsSync(dir)) continue;
+    let entries;
+    try { entries = readdirSync(dir); } catch { continue; }
+    for (const name of entries) {
+      if (name.startsWith('.')) continue;
+      const abs = join(dir, name);
+      try {
+        if (statSync(abs).isDirectory()) paths.push(abs);
+      } catch { /* skip */ }
+    }
+  }
+  return paths;
+}
+
+// Score how well a claude-mem project name matches a disk path.
+// Returns { confidence: 0..1, evidence: string } or null.
+//   1.0  -- exact basename match
+//   0.9  -- normalized match (lowercase, strip punctuation)
+//   0.8  -- normalized prefix/suffix (claude-mem name starts or ends with path basename)
+//   0.7  -- contains match (one name contains the other, len >= 4)
+//   null -- no match
+function scoreMatch(projectName, diskPath) {
+  if (!projectName || !diskPath) return null;
+  const pn = String(projectName);
+  const dn = basename(diskPath);
+
+  if (pn === dn) return { confidence: 1.0, evidence: 'exact basename match' };
+
+  const norm = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, '');
+  const pnN = norm(pn);
+  const dnN = norm(dn);
+  if (!pnN || !dnN) return null;
+  if (pnN === dnN) return { confidence: 0.9, evidence: 'normalized match' };
+
+  if (pnN.startsWith(dnN) || dnN.startsWith(pnN) ||
+      pnN.endsWith(dnN) || dnN.endsWith(pnN)) {
+    if (Math.min(pnN.length, dnN.length) >= 4) {
+      return { confidence: 0.8, evidence: 'normalized prefix/suffix' };
+    }
+  }
+
+  // Also handle cases where claude-mem stores a full path as project
+  // (some claude-mem versions do this).
+  if (pn.includes('/') && pn.endsWith('/' + dn)) {
+    return { confidence: 1.0, evidence: 'path suffix match' };
+  }
+
+  if (pnN.length >= 4 && dnN.length >= 4) {
+    if (pnN.includes(dnN) || dnN.includes(pnN)) {
+      return { confidence: 0.7, evidence: 'substring match' };
+    }
+  }
+
+  return null;
+}
+
+// Build a candidate list of disk paths for a given claude-mem project name.
+// Sorted by confidence descending.
+export function matchProjectToPaths(projectName, knownPaths) {
+  const matches = [];
+  for (const p of knownPaths) {
+    const score = scoreMatch(projectName, p);
+    if (score) matches.push({ path: p, ...score });
+  }
+  matches.sort((a, b) => b.confidence - a.confidence);
+  return matches;
+}
+
+// Read distinct project values from claude-mem. Also returns entry counts.
+// Returns Map<projectName, count>.
+export async function readClaudeMemProjects(dbPath) {
+  let sqliteMod;
+  try {
+    sqliteMod = await import('node:sqlite');
+  } catch {
+    throw new Error(
+      'claude-mem discovery needs Node 22.5+ for built-in SQLite.'
+    );
+  }
+  const { DatabaseSync } = sqliteMod;
+  const db = new DatabaseSync(dbPath, { readOnly: true });
+  try {
+    // Check that the project column exists -- schema varies across versions.
+    const cols = db.prepare('PRAGMA table_info(observations)').all();
+    const hasProject = cols.some((c) => c.name === 'project');
+    if (!hasProject) {
+      // No project column -- everything goes to a single "unknown" bucket.
+      const total = db.prepare('SELECT COUNT(*) as c FROM observations').get().c;
+      return new Map([[null, total]]);
+    }
+    const rows = db
+      .prepare(`SELECT COALESCE(project, '') as project, COUNT(*) as n
+                  FROM observations
+                  GROUP BY project
+                  ORDER BY n DESC`)
+      .all();
+    const map = new Map();
+    for (const r of rows) {
+      const key = r.project ? String(r.project) : null;
+      map.set(key, r.n);
+    }
+    return map;
+  } finally {
+    db.close();
+  }
+}
+
+// Top-level planner. Returns the full plan for --all mode.
+export async function buildProjectPlan({ dbPath, home = homedir() } = {}) {
+  const projects = await readClaudeMemProjects(dbPath);
+  const knownPaths = [
+    ...new Set([
+      ...discoverKnownProjectPaths({ home }),
+      ...discoverDevParentPaths({ home }),
+    ]),
+  ];
+
+  const matched = [];
+  const ambiguous = [];
+  const unmatched = [];
+
+  for (const [projectName, count] of projects.entries()) {
+    if (!projectName) {
+      unmatched.push({ project: '(no project tag)', entryCount: count });
+      continue;
+    }
+    const candidates = matchProjectToPaths(projectName, knownPaths);
+    if (candidates.length === 0) {
+      unmatched.push({ project: projectName, entryCount: count });
+      continue;
+    }
+    const top = candidates[0];
+    const highConfidence = candidates.filter((c) => c.confidence >= 0.9);
+    // Single high-confidence match = auto-matched. Two or more high-confidence
+    // matches = ambiguous, ask the user.
+    if (highConfidence.length === 1) {
+      matched.push({
+        project: projectName,
+        path: top.path,
+        entryCount: count,
+        confidence: top.confidence,
+        evidence: top.evidence,
+      });
+    } else if (highConfidence.length > 1) {
+      ambiguous.push({
+        project: projectName,
+        entryCount: count,
+        candidates: highConfidence,
+      });
+    } else {
+      // Only low-confidence matches -- treat as ambiguous so user can decide
+      // or route to global archive.
+      ambiguous.push({
+        project: projectName,
+        entryCount: count,
+        candidates: candidates.slice(0, 3),
+      });
+    }
+  }
+
+  return {
+    source: dbPath,
+    matched,
+    ambiguous,
+    unmatched,
+    totalEntries: [...projects.values()].reduce((a, b) => a + b, 0),
+  };
+}
+
+// For tests.
+export const _internal = { scoreMatch, decodeClaudeProjectDir };

package/src/importers/rtk.js

@@ -0,0 +1,107 @@
+// --- RTK importer (scaffold) ---
+//
+// RTK is a third-party Claude Code context-trimming / memory plugin
+// (referenced in prior IJFW handoffs alongside claude-mem). The exact npm
+// name + on-disk layout are pinned in .planning/phase12/IMPORTER-SCHEMAS.md
+// after Phase 12 schema-research. This scaffold parses the two plausible
+// layouts (single JSON doc and per-file dir) so fixture-based tests run
+// green while the real format is nailed down.
+
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, extname } from 'node:path';
+import { homedir } from 'node:os';
+import { makeEntry } from './common.js';
+
+export const NAME = 'rtk';
+
+export function detect({ home = homedir(), path = null } = {}) {
+  const candidates = path ? [path] : [
+    join(home, '.rtk'),
+    join(home, '.claude', 'rtk'),
+    join(home, '.config', 'rtk'),
+  ];
+  for (const p of candidates) {
+    if (existsSync(p)) {
+      const stats = statSync(p);
+      return { found: true, path: p, isDir: stats.isDirectory() };
+    }
+  }
+  return { found: false, path: null };
+}
+
+export function* readSource(path) {
+  if (!path || !existsSync(path)) return;
+
+  const stat = statSync(path);
+  if (stat.isFile() && path.endsWith('.json')) {
+    try {
+      const doc = JSON.parse(readFileSync(path, 'utf8'));
+      yield* flattenRtk(doc);
+    } catch { /* skip malformed root doc */ }
+    return;
+  }
+
+  if (stat.isDirectory()) {
+    const index = join(path, 'index.json');
+    if (existsSync(index)) {
+      try {
+        const doc = JSON.parse(readFileSync(index, 'utf8'));
+        yield* flattenRtk(doc);
+      } catch { /* skip */ }
+      return;
+    }
+    for (const name of readdirSync(path)) {
+      if (extname(name) !== '.json') continue;
+      try {
+        const doc = JSON.parse(readFileSync(join(path, name), 'utf8'));
+        yield* flattenRtk(doc);
+      } catch { /* skip */ }
+    }
+  }
+}
+
+// RTK docs often wrap entries under `entries`, `memories`, or `contexts`.
+function* flattenRtk(doc) {
+  if (!doc) return;
+  if (Array.isArray(doc)) { for (const r of doc) yield r; return; }
+  if (typeof doc !== 'object') return;
+  for (const key of ['entries', 'memories', 'contexts', 'items']) {
+    if (Array.isArray(doc[key])) { for (const r of doc[key]) yield r; return; }
+  }
+  yield doc;
+}
+
+export function normalize(record) {
+  if (!record || typeof record !== 'object') return null;
+
+  const content =
+    record.content ||
+    record.text ||
+    record.body ||
+    record.context ||
+    '';
+  if (!content) return null;
+
+  const rawType = record.type || record.category || record.kind || 'observation';
+  const mapped = mapType(rawType);
+  if (!mapped) return null;
+
+  return makeEntry({
+    type: mapped,
+    content,
+    summary: record.title || record.label || record.summary || null,
+    why: record.rationale || record.why || null,
+    how_to_apply: record.guidance || record.how_to_apply || null,
+    tags: Array.isArray(record.tags) ? record.tags.map(String) : [],
+    source: NAME,
+  });
+}
+
+function mapType(raw) {
+  const t = String(raw).toLowerCase();
+  if (t.includes('decision'))   return 'decision';
+  if (t.includes('pattern'))    return 'pattern';
+  if (t.includes('preference')) return 'preference';
+  if (t.includes('handoff'))    return 'handoff';
+  return 'observation';
+}

package/src/intent-router.js

@@ -0,0 +1,221 @@
+// --- Intent router (W2.1 / A1) ---
+// Deterministic keyword → skill dispatch. Runs in UserPromptSubmit hook
+// before the vague-prompt check. When a recognized intent hits, emits a
+// positive-framed nudge that tells the agent which IJFW skill/tool to use.
+//
+// This is the "brainstorm auto-fires workflow" moment: we don't leave the
+// matching to the LLM; we match deterministically and surface the choice.
+//
+// Policy: high precision over recall. False positives are expensive (wrong
+// skill fired), false negatives cheap (agent just picks normally).
+
+const INTENTS = [
+  {
+    intent: 'brainstorm',
+    skill:  'ijfw-workflow',
+    priority: 8,  // High: primary workflow entry point, should beat most other intents
+    // Bare "build" is too vague; "build X" + "brainstorm" + "let's design"
+    // are the high-signal ones.
+    patterns: [
+      /\bbrainstorm(?:\s|ing)\b/i,
+      /\blet'?s\s+(?:think|design|plan|figure)\b/i,
+      /\b(?:new project|starting a project|greenfield)\b/i,
+      /\bhelp me (?:build|design|plan|figure)\b/i,
+      // Non-software project triggers
+      /\b(build|create|design|launch|start|develop|write|outline)\s+(a|an|the|my|our)\s+(?!pr\b|commit\b|branch\b|tag\b|comment\b|variable\b|file\b|line\b|test\b|function\b|class\b|method\b)\w{3,}/i,
+      /\b(?:build|create|design|launch|plan|make|start)\s+(?:a|an|the|my|our)\s+(?:landing page|website|app|dashboard|campaign|book|course|brand|product|platform|service)\b/i,
+      /\b(from scratch|greenfield|new\s+(?:project|venture|initiative|business|idea))\b/i,
+      /\b(strategy for|roadmap for|plan for|outline for)\b/i,
+      /\b(social media|content marketing|email sequence|sales funnel|launch plan)\b/i,
+    ],
+    nudge: "Looks like you want to plan a new project. Try: /ijfw-workflow (quick mode for rapid exploration, deep mode for full project planning).",
+  },
+  {
+    intent: 'project-scale',
+    skill:  'ijfw-workflow',
+    priority: 7,  // Just below brainstorm -- scale detection is a fallback for non-keyword matches
+    patterns: [], // no keyword patterns -- uses check() instead
+    check: (prompt) => {
+      const words = prompt.split(/\s+/).length;
+      const hasMultipleDeliverables = (prompt.match(/\band\b/gi) || []).length >= 2;
+      const hasTimeline = /\b(by|before|deadline|launch|next\s+(week|month)|this\s+(week|month))\b/i.test(prompt);
+      const hasBudget = /\$\d|budget|resource|team of/i.test(prompt);
+      const hasScope = /\b(full|complete|entire|end.to.end|comprehensive)\b/i.test(prompt);
+      return words > 40 && (hasMultipleDeliverables || hasTimeline || hasBudget || hasScope);
+    },
+    nudge: 'This sounds like a project. Want me to brainstorm it with you? I\'ll ask a few questions, do some research, and come back with recommendations.',
+  },
+  {
+    intent: 'ship',
+    skill:  'ijfw-commit',
+    priority: 5,
+    patterns: [
+      /\b(?:ship it|let'?s ship|ready to commit|commit this|push this)\b/i,
+      /\bmake a commit\b/i,
+      /\b(?:create|open) (?:a )?PR\b/i,
+    ],
+    nudge: "Looks like you want to commit and ship your changes. Try: /ijfw-commit for a terse conventional commit, then open a PR following your git conventions.",
+  },
+  {
+    intent: 'review',
+    skill:  'ijfw-review',
+    priority: 5,
+    patterns: [
+      /\b(?:code review|review (?:the|this|my) (?:code|diff|PR|change))/i,
+      /\breview PR\b/i,
+    ],
+    nudge: "Looks like you want to review code or a diff. Try: /ijfw-review for concise, actionable findings.",
+  },
+  {
+    intent: 'remember',
+    skill:  'ijfw_memory_store',
+    priority: 5,
+    patterns: [
+      /\b(?:remember (?:this|that)|store (?:this|that)|save (?:this|that) (?:for (?:later|next time)|to memory))\b/i,
+      /\b(?:this is|that'?s) important (?:to remember|for (?:later|next time))\b/i,
+      /\b(?:note to self|save for later)\b/i,
+    ],
+    nudge: "Looks like you want to save something to memory. Try: ijfw_memory_store with a type (decision, observation, pattern, handoff, or preference) and a brief summary.",
+  },
+  {
+    intent: 'recall',
+    skill:  'ijfw_memory_recall',
+    priority: 5,
+    patterns: [
+      /\b(?:what did we|what (?:did|have) I|do you remember)\b/i,
+      /\b(?:recall|pull up|look up) (?:from|in) memory\b/i,
+      /\bshow me what you remember\b/i,
+    ],
+    nudge: "Looks like you want to recall something from memory. Try: ijfw_memory_recall or ijfw_memory_search to pull up what was stored.",
+  },
+  {
+    intent: 'cross-research',
+    skill:  '/cross-research',
+    priority: 10,
+    patterns: [
+      /\bcross[- ]?research(?:\s|ing)?\b/i,
+      /\blet'?s cross[- ]?research\b/i,
+      /\bdig into .+ from multiple angles\b/i,
+      /\bmulti[- ]?angle research\b/i,
+      /\bresearch (?:this|that) from multiple angles\b/i,
+    ],
+    nudge: "Looks like you want to research a topic from multiple angles. Try: /cross-research (auto-detects target; no args needed). Phase A fans out to Codex and Gemini in parallel, Phase B synthesizes results -- all via background bash.",
+  },
+  {
+    intent: 'cross-critique',
+    skill:  '/cross-critique',
+    priority: 10,
+    patterns: [
+      /\bcross[- ]?critique(?:\s|ing)?\b/i,
+      /\blet'?s cross[- ]?critique\b/i,
+      /\bstress[- ]?test this claim\b/i,
+      /\badversarial (?:critique|review)\b/i,
+      /\bchallenge this from every angle\b/i,
+      /\battack this from all sides\b/i,
+    ],
+    nudge: "Looks like you want to stress-test a claim or plan from multiple angles. Try: /cross-critique (auto-detects target). Codex covers technical weaknesses, Gemini covers strategic weaknesses, and a fresh Claude instance covers UX and adoption -- all auto-fired via background bash.",
+  },
+  {
+    intent: 'critique',
+    skill:  'ijfw-critique',
+    priority: 1,
+    patterns: [
+      /\b(?:should I|what if|is this (?:right|correct|the best))\b/i,
+      /\b(?:critique|poke holes|challenge this)\b/i,
+      /\b(?:counter[- ]?argument|devil'?s advocate)\b/i,
+    ],
+    nudge: "Looks like you want to pressure-test an idea or plan. Try: /ijfw-critique -- steelmans the current approach, then surfaces 2-3 concrete counter-arguments with the conditions that trigger each.",
+  },
+  {
+    intent: 'cross-audit',
+    skill:  '/cross-audit',
+    priority: 10,
+    patterns: [
+      /\bcross[- ]?audit(?:\s|ing)?\b/i,
+      /\b(?:get|need)\s+(?:a\s+)?second opinion\b/i,
+      /\b(?:have|ask)\s+(?:codex|gemini|opencode|aider|copilot)\s+(?:to\s+)?(?:review|audit|check)\b/i,
+      /\bsecond[- ]model (?:review|opinion|audit)\b/i,
+      /\b(?:peer|adversarial)[- ]?(?:review|audit)\b/i,
+    ],
+    nudge: "Looks like you want a second-model audit of your code. Try: /cross-audit (no args = auto-picks staged and recent-change files; --with <id> to target a specific auditor). Writes .ijfw/cross-audit/request.md and auto-fires the auditor via background bash.",
+  },
+  {
+    intent: 'handoff',
+    skill:  'ijfw-handoff',
+    priority: 5,
+    patterns: [
+      /\b(?:session (?:handoff|summary)|wrapping up|end of session)\b/i,
+      /\bcontext (?:is )?getting full\b/i,
+    ],
+    nudge: "Looks like you want to wrap up this session cleanly. Try: /ijfw-handoff -- writes a structured handoff with decisions made, next steps, and open questions.",
+  },
+  {
+    intent: 'mode-brutal',
+    skill:  'ijfw-core',
+    priority: 5,
+    patterns: [
+      /\b(?:brutal mode|be brutal|caveman mode|ultra[- ]?terse)\b/i,
+    ],
+    nudge: "Looks like you want maximum terseness. Try: /ijfw-mode brutal -- code and single-sentence answers only, no narration unless you ask.",
+  },
+];
+
+function adaptProjectScaleNudge(prompt) {
+  const p = prompt.toLowerCase();
+  let verb;
+  if (/\b(app|api|dashboard|backend|frontend|service|platform|software|saas|microservice)\b/.test(p)) {
+    verb = 'brainstorm the architecture';
+  } else if (/\b(book|outline|chapter|manuscript|write)\b/.test(p)) {
+    verb = 'outline the structure';
+  } else if (/\b(campaign|marketing|social|email sequence|sales funnel|launch plan|content)\b/.test(p)) {
+    verb = 'plan the strategy';
+  } else if (/\b(design|landing page|ui|ux|brand|visual)\b/.test(p)) {
+    verb = 'explore the design';
+  } else {
+    verb = 'map out the approach';
+  }
+  return `This sounds like a project. Want me to ${verb} with you? I'll ask a few questions, do some research, and come back with recommendations.`;
+}
+
+export function detectIntent(prompt) {
+  if (typeof prompt !== 'string' || !prompt) return null;
+  // Skip if user explicitly bypasses (leading * or `ijfw off`).
+  if (/^\s*\*/.test(prompt)) return null;
+  if (/\bijfw off\b/i.test(prompt)) return null;
+
+  // Collect ALL matching entries with the longest matching pattern length.
+  const matches = [];
+  for (const entry of INTENTS) {
+    // check() function takes precedence over patterns for entries that declare it.
+    if (typeof entry.check === 'function') {
+      if (entry.check(prompt)) {
+        matches.push({ entry, matchLen: 0 });
+      }
+      continue;
+    }
+    for (const re of entry.patterns) {
+      const m = prompt.match(re);
+      if (m) {
+        matches.push({ entry, matchLen: m[0].length });
+        break; // one match per entry is enough
+      }
+    }
+  }
+
+  if (matches.length === 0) return null;
+
+  // Sort: (a) priority DESC, (b) matchLen DESC, (c) INTENTS array order ASC (stable via index).
+  matches.sort((a, b) => {
+    const pd = (b.entry.priority ?? 0) - (a.entry.priority ?? 0);
+    if (pd !== 0) return pd;
+    const ld = b.matchLen - a.matchLen;
+    if (ld !== 0) return ld;
+    return INTENTS.indexOf(a.entry) - INTENTS.indexOf(b.entry);
+  });
+
+  const winner = matches[0].entry;
+  const nudge = winner.intent === 'project-scale'
+    ? adaptProjectScaleNudge(prompt)
+    : winner.nudge;
+  return { intent: winner.intent, skill: winner.skill, nudge };
+}