wayfind 2.0.69 → 2.0.70

package/bin/connectors/llm.js

@@ -302,6 +302,92 @@ async function call(config, systemPrompt, userContent) {
   }
 }
 
+// ── Tool-use relay ──────────────────────────────────────────────────────────
+
+/**
+ * Call the Anthropic API with tool-use support, looping until the model stops.
+ * @param {Object} config - Provider configuration (must be Anthropic)
+ * @param {string} systemPrompt - System prompt
+ * @param {string} userContent - User message text
+ * @param {Array} tools - Anthropic tool-use format tool definitions
+ * @param {Function} handleToolCall - async (name, input) => result
+ * @returns {Promise<string>} - Final text response
+ */
+async function callWithTools(config, systemPrompt, userContent, tools, handleToolCall) {
+  const apiKey = process.env[config.api_key_env];
+  if (!apiKey) {
+    throw new Error(`Anthropic: Missing API key. Set ${config.api_key_env} environment variable.`);
+  }
+
+  const headers = {
+    'x-api-key': apiKey,
+    'anthropic-version': ANTHROPIC_VERSION,
+  };
+
+  const MAX_ITERATIONS = 10;
+  let messages = [{ role: 'user', content: userContent }];
+
+  for (let i = 0; i < MAX_ITERATIONS; i++) {
+    const payload = JSON.stringify({
+      model: config.model,
+      max_tokens: config.max_tokens || DEFAULT_MAX_TOKENS,
+      system: systemPrompt,
+      messages,
+      tools,
+    });
+
+    const res = await httpPost(ANTHROPIC_API_URL, headers, payload);
+    checkResponse(res, 'Anthropic');
+
+    let data;
+    try {
+      data = JSON.parse(res.body);
+    } catch {
+      throw new Error('Anthropic: Failed to parse response JSON.');
+    }
+
+    if (!data.content || !Array.isArray(data.content)) {
+      throw new Error('Anthropic: Response missing content array.');
+    }
+
+    // If the model is done, extract and return the final text
+    if (data.stop_reason !== 'tool_use') {
+      const textBlock = data.content.find(b => b.type === 'text');
+      return textBlock ? textBlock.text : '';
+    }
+
+    // Process tool calls
+    const toolUseBlocks = data.content.filter(b => b.type === 'tool_use');
+    if (toolUseBlocks.length === 0) {
+      // stop_reason is tool_use but no tool_use blocks — treat as done
+      const textBlock = data.content.find(b => b.type === 'text');
+      return textBlock ? textBlock.text : '';
+    }
+
+    // Build tool results
+    const toolResults = [];
+    for (const block of toolUseBlocks) {
+      let result;
+      try {
+        result = await handleToolCall(block.name, block.input);
+      } catch (err) {
+        result = { error: err.message };
+      }
+      toolResults.push({
+        type: 'tool_result',
+        tool_use_id: block.id,
+        content: typeof result === 'string' ? result : JSON.stringify(result),
+      });
+    }
+
+    // Append assistant message + tool results, then loop
+    messages.push({ role: 'assistant', content: data.content });
+    messages.push({ role: 'user', content: toolResults });
+  }
+
+  throw new Error('Anthropic: Tool-use loop exceeded maximum iterations (10).');
+}
+
 // ── Auto-detect available provider ───────────────────────────────────────────
 
 /**
@@ -535,6 +621,7 @@ async function generateEmbeddingAzure(text, options = {}) {
 
 module.exports = {
   call,
+  callWithTools,
   detect,
   generateEmbedding,
   getEmbeddingProviderInfo,

package/bin/content-store.js

@@ -610,7 +610,7 @@ async function indexJournals(options = {}) {
 
 /**
  * Search journals using semantic similarity.
- * Falls back to searchText() if no embeddings available.
+ * Falls back to queryMetadata() browse if no embeddings available.
  * @param {string} query - Search query
  * @param {Object} [options]
  * @param {string} [options.storePath] - Content store directory
@@ -633,7 +633,11 @@ async function searchJournals(query, options = {}) {
   const hasEmbeddings = Object.keys(embeddings).length > 0;
 
   if (!hasEmbeddings) {
-    return searchText(query, options);
+    const browseResults = queryMetadata(options);
+    return browseResults.slice(0, limit).map(r => ({
+      ...r, score: null,
+      _hint: 'Semantic search unavailable — showing recent entries by date. Run "wayfind reindex" to enable semantic search.',
+    }));
   }
 
   // Generate query embedding
@@ -641,8 +645,12 @@ async function searchJournals(query, options = {}) {
   try {
     queryVec = await llm.generateEmbedding(query);
   } catch {
-    // Fall back to text search if embedding fails
-    return searchText(query, options);
+    // Fall back to browse if embedding generation fails
+    const browseResults = queryMetadata(options);
+    return browseResults.slice(0, limit).map(r => ({
+      ...r, score: null,
+      _hint: 'Semantic search unavailable — showing recent entries by date. Run "wayfind reindex" to enable semantic search.',
+    }));
   }
 
   // Score all entries
@@ -662,143 +670,6 @@ async function searchJournals(query, options = {}) {
   return results.slice(0, limit);
 }
 
-/**
- * Full-text search across journal entries.
- * Works without any API key. Matches query words against title, repo, tags.
- * @param {string} query - Search query
- * @param {Object} [options]
- * @param {string} [options.storePath] - Content store directory
- * @param {number} [options.limit] - Max results (default: 10)
- * @param {string} [options.repo] - Filter by repo
- * @param {string} [options.since] - Filter by date (YYYY-MM-DD)
- * @param {string} [options.until] - Filter by date (YYYY-MM-DD)
- * @param {boolean} [options.drifted] - Filter by drift status
- * @returns {Array<{ id: string, score: number, entry: Object }>}
- */
-function searchText(query, options = {}) {
-  const storePath = options.storePath || resolveStorePath();
-  const journalDir = options.journalDir || DEFAULT_JOURNAL_DIR;
-  const limit = options.limit || 10;
-
-  const index = getBackend(storePath).loadIndex();
-  if (!index) return [];
-
-  // Normalize: split on whitespace, hyphens, underscores
-  const queryWords = query.toLowerCase().split(/[\s\-_]+/).filter(w => w.length > 1);
-  if (queryWords.length === 0) return [];
-
-  // Pre-load journal content for full-text search (cache by date+user key)
-  const journalCache = {};
-  function getJournalContent(date, user) {
-    const cacheKey = user ? `${date}-${user}` : date;
-    if (journalCache[cacheKey] !== undefined) return journalCache[cacheKey];
-    if (!journalDir) { journalCache[cacheKey] = null; return null; }
-    // Try authored filename first, then plain date filename
-    const candidates = user
-      ? [path.join(journalDir, `${date}-${user}.md`), path.join(journalDir, `${date}.md`)]
-      : [path.join(journalDir, `${date}.md`)];
-    let content = null;
-    for (const filePath of candidates) {
-      try {
-        content = fs.readFileSync(filePath, 'utf8').toLowerCase();
-        break;
-      } catch {
-        // Try next candidate
-      }
-    }
-    journalCache[cacheKey] = content;
-    return content;
-  }
-
-  const results = [];
-  for (const [id, entry] of Object.entries(index.entries)) {
-    if (!applyFilters(entry, options)) continue;
-
-    // Build searchable text from entry metadata (normalize hyphens/underscores)
-    let searchable = [
-      entry.title,
-      entry.repo,
-      entry.date,
-      entry.user,
-      ...(entry.tags || []),
-    ].filter(Boolean).join(' ').toLowerCase().replace(/[-_]/g, ' ');
-
-    // For signal entries, read content directly from the signal file
-    if (entry.source === 'signal') {
-      const signalsDir = options.signalsDir || resolveSignalsDir();
-      if (signalsDir) {
-        // Signal files live at signalsDir/<channel>/<date>.md or signalsDir/<channel>/<owner>/<repo>/<date>.md
-        // The repo field tells us the path: "signals/<channel>" or "<owner>/<repo>"
-        const repo = entry.repo || '';
-        const candidates = [];
-        if (repo.startsWith('signals/')) {
-          const channel = repo.replace('signals/', '');
-          candidates.push(path.join(signalsDir, channel, `${entry.date}.md`));
-          candidates.push(path.join(signalsDir, channel, `${entry.date}-summary.md`));
-        } else if (repo.includes('/')) {
-          // owner/repo format — find which channel it's under
-          for (const channel of ['github', 'intercom', 'notion']) {
-            candidates.push(path.join(signalsDir, channel, repo, `${entry.date}.md`));
-          }
-        }
-        for (const fp of candidates) {
-          try {
-            const content = fs.readFileSync(fp, 'utf8').toLowerCase();
-            searchable += ' ' + content.replace(/[-_]/g, ' ');
-            break;
-          } catch {
-            // Try next candidate
-          }
-        }
-      }
-    }
-
-    // Also include the full journal entry content if available
-    const journalContent = entry.source !== 'signal' ? getJournalContent(entry.date, entry.user) : null;
-    if (journalContent) {
-      // Find this entry's section in the journal file.
-      // Try exact match first, then normalize hyphens/spaces for fuzzy match.
-      const repoTitle = `${entry.repo} — ${entry.title}`.toLowerCase();
-      let idx = journalContent.indexOf(repoTitle);
-      if (idx === -1) {
-        // Normalize both sides: collapse hyphens, underscores, em-dashes, and extra spaces
-        const norm = (s) => s.replace(/[-_\u2014\u2013]/g, ' ').replace(/\s+/g, ' ').trim();
-        const normalized = norm(repoTitle);
-        // Search through journal headers for a normalized match
-        const headerRegex = /\n## (.+)/g;
-        let match;
-        while ((match = headerRegex.exec(journalContent)) !== null) {
-          const headerNorm = norm(match[1]);
-          if (headerNorm.includes(normalized) || normalized.includes(headerNorm)) {
-            idx = match.index + 1; // skip the \n
-            break;
-          }
-        }
-      }
-      if (idx !== -1) {
-        // Extract from header to next header (or end of file)
-        const nextHeader = journalContent.indexOf('\n## ', idx + 1);
-        const section = nextHeader !== -1 ? journalContent.slice(idx, nextHeader) : journalContent.slice(idx);
-        searchable += ' ' + section.replace(/[-_]/g, ' ');
-      }
-    }
-
-    // Score: count of matching query words
-    let matches = 0;
-    for (const word of queryWords) {
-      if (searchable.includes(word)) matches++;
-    }
-
-    if (matches > 0) {
-      const score = Math.round((matches / queryWords.length) * 1000) / 1000;
-      results.push({ id, score, entry });
-    }
-  }
-
-  results.sort((a, b) => b.score - a.score);
-  return results.slice(0, limit);
-}
-
 /**
  * Apply metadata filters to an entry.
  * @param {Object} entry
@@ -2480,7 +2351,6 @@ module.exports = {
   applyContextShiftToState,
   generateOnboardingPack,
   searchJournals,
-  searchText,
   queryMetadata,
   extractInsights,
   computeQualityProfile,

package/bin/mcp-server.js

@@ -228,43 +228,32 @@ async function proxyGetEntry(id) {
 const TOOLS = [
   {
     name: 'search_context',
-    description: 'Search the team\'s full decision history across all repos and all engineers. Returns ranked journal entries, decisions, and signals. Use this — not file reads — to answer any question about past work, architectural decisions, what was decided, or team activity. The content store covers history that state files cannot.',
+    description: 'Search the team\'s decision history across all repos and engineers. Returns ranked entries. Use mode=browse with since/until for time-range queries ("what happened this week"). Use mode=semantic with a query for topical searches. Pass dates, authors, and repos as explicit parameters.',
     inputSchema: {
       type: 'object',
       properties: {
-        query: { type: 'string', description: 'Natural language search query' },
+        query: { type: 'string', description: 'Natural language search query (required for semantic mode, optional for browse)' },
         limit: { type: 'number', description: 'Max results (default: 10)' },
         repo: { type: 'string', description: 'Filter by repository name (e.g. "MyService", "MyOrg/my-repo")' },
         since: { type: 'string', description: 'Filter to entries on or after this date (YYYY-MM-DD)' },
-        mode: { type: 'string', enum: ['semantic', 'text'], description: 'Search mode — semantic uses embeddings, text uses keyword matching. Defaults to semantic if embeddings available.' },
+        until: { type: 'string', description: 'Filter to entries on or before this date (YYYY-MM-DD)' },
+        user: { type: 'string', description: 'Filter by author slug (lowercase first name, e.g. "nick")' },
+        source: { type: 'string', enum: ['journal', 'conversation', 'signal'], description: 'Filter by entry source type' },
+        mode: { type: 'string', enum: ['semantic', 'browse'], description: 'Search strategy. semantic (default) uses embeddings for relevance ranking. browse returns entries sorted by date (best for time-range queries).' },
       },
-      required: ['query'],
     },
   },
   {
     name: 'get_entry',
-    description: 'Retrieve the full content of a specific journal or signal entry by ID. Use the IDs returned by search_context or list_recent.',
+    description: 'Retrieve the full content of a specific journal or signal entry by ID. Use the IDs returned by search_context.',
     inputSchema: {
       type: 'object',
       properties: {
-        id: { type: 'string', description: 'Entry ID from search_context or list_recent results' },
+        id: { type: 'string', description: 'Entry ID from search_context results' },
       },
       required: ['id'],
     },
   },
-  {
-    name: 'list_recent',
-    description: 'List recent journal entries and decisions, optionally filtered by repo or date range. Returns metadata (no full content — use get_entry for that).',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        limit: { type: 'number', description: 'Max entries to return (default: 20)' },
-        repo: { type: 'string', description: 'Filter by repository name' },
-        since: { type: 'string', description: 'Filter to entries on or after this date (YYYY-MM-DD)' },
-        source: { type: 'string', enum: ['journal', 'conversation', 'signal'], description: 'Filter by entry source type' },
-      },
-    },
-  },
   {
     name: 'get_signals',
     description: 'Retrieve recent signal entries (GitHub activity, Slack summaries, Intercom updates, Notion pages) for a specific channel or all channels.',
@@ -327,26 +316,53 @@ const TOOLS = [
 // ── Tool handlers ────────────────────────────────────────────────────────────
 
 async function handleSearchContext(args) {
-  const { query, limit = 10, repo, since, mode } = args;
+  const { query, limit = 10, repo, since, until, user, source, mode: rawMode } = args;
+
+  // Auto-switch to browse if no query provided
+  const mode = (!query && rawMode !== 'browse') ? 'browse' : (rawMode || 'semantic');
 
-  // Try container first for semantic search (has embeddings for full team)
-  if (mode !== 'text') {
-    const containerResult = await proxySearch({ query, limit, repo, since, mode });
+  // Browse mode — return entries sorted by date (no embeddings needed)
+  if (mode === 'browse') {
+    const opts = { limit, repo, since, until, user, source };
+
+    // Try container first
+    const containerResult = await proxySearch({ query, limit, repo, since, until, user, source, mode: 'browse' });
     if (containerResult && containerResult.found > 0) {
       containerResult.source = 'container';
       return containerResult;
     }
+
+    // Fall back to local
+    const results = contentStore.queryMetadata(opts);
+    const top = results.slice(0, limit);
+    return {
+      found: results.length,
+      showing: top.length,
+      source: 'local',
+      results: top.map(r => ({
+        id: r.id,
+        date: r.entry.date,
+        repo: r.entry.repo,
+        title: r.entry.title,
+        source: r.entry.source,
+        user: r.entry.user || null,
+        tags: r.entry.tags || [],
+        summary: r.entry.summary || null,
+      })),
+    };
   }
 
-  // Fall back to local search
-  const opts = { limit, repo, since };
-  let results;
-  if (mode === 'text') {
-    results = contentStore.searchText(query, opts);
-  } else {
-    results = await contentStore.searchJournals(query, opts);
+  // Semantic mode — try container first (has embeddings for full team)
+  const containerResult = await proxySearch({ query, limit, repo, since, until, user, source, mode });
+  if (containerResult && containerResult.found > 0) {
+    containerResult.source = 'container';
+    return containerResult;
   }
 
+  // Fall back to local semantic search
+  const opts = { limit, repo, since, until, user, source };
+  const results = await contentStore.searchJournals(query, opts);
+
   if (!results || results.length === 0) {
     return { found: 0, results: [], source: 'local', hint: 'No matches. Try a broader query or check wayfind reindex.' };
   }
@@ -361,6 +377,7 @@ async function handleSearchContext(args) {
       repo: r.entry.repo,
       title: r.entry.title,
       source: r.entry.source,
+      user: r.entry.user || null,
       tags: r.entry.tags || [],
       summary: r.entry.summary || null,
     })),
@@ -397,25 +414,6 @@ async function handleGetEntry(args) {
   return { error: `Entry not found: ${id}` };
 }
 
-function handleListRecent(args) {
-  const { limit = 20, repo, since, source } = args;
-  const opts = { limit, repo, since, source };
-  const results = contentStore.queryMetadata(opts);
-  const top = results.slice(0, limit);
-
-  return {
-    total: results.length,
-    showing: top.length,
-    entries: top.map(r => ({
-      id: r.id,
-      date: r.entry.date,
-      repo: r.entry.repo,
-      title: r.entry.title,
-      source: r.entry.source,
-      tags: r.entry.tags || [],
-    })),
-  };
-}
 
 function handleGetSignals(args) {
   const { channel, limit = 20 } = args;
@@ -590,7 +588,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   switch (name) {
     case 'search_context':   result = await handleSearchContext(args); break;
     case 'get_entry':        result = await handleGetEntry(args); break;
-    case 'list_recent':      result = handleListRecent(args); break;
     case 'get_signals':      result = handleGetSignals(args); break;
     case 'get_team_status':  result = handleGetTeamStatus(args); break;
     case 'get_personas':     result = handleGetPersonas(); break;