wayfind 2.0.53 → 2.0.55

package/bin/content-store.js

@@ -979,6 +979,13 @@ function getEntryContent(entryId, options = {}) {
     return null;
   }
 
+  // ── Distilled entries ───────────────────────────────────────────────────
+  if (entry.source === 'distilled') {
+    try {
+      return fs.readFileSync(path.join(storePath, 'distilled', `${entryId}.md`), 'utf8');
+    } catch { return null; }
+  }
+
   // ── Conversation entries ────────────────────────────────────────────────
   if (entry.source === 'conversation') {
     // Try journal path first (for --export'd conversations)

package/bin/distill.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const fs = require('fs');
+const path = require('path');
 const contentStore = require('./content-store');
 const llm = require('./connectors/llm');
 
@@ -319,6 +321,16 @@ async function distillEntries(options = {}) {
 
           index.entryCount = Object.keys(index.entries).length;
           backend.saveIndex(index);
+
+          // Persist merged content to disk so it survives export/import
+          try {
+            const distilledDir = path.join(storePath, 'distilled');
+            if (!fs.existsSync(distilledDir)) fs.mkdirSync(distilledDir, { recursive: true });
+            fs.writeFileSync(path.join(distilledDir, `${id}.md`), content, 'utf8');
+          } catch (writeErr) {
+            console.log(`    Warning: could not persist distilled content: ${writeErr.message}`);
+          }
+
           totalStats.merged += cluster.length;
         } catch (err) {
           console.log(`    Merge failed for cluster: ${err.message}`);
@@ -343,6 +355,114 @@ async function distillEntries(options = {}) {
   return totalStats;
 }
 
+// ── Export / Import ──────────────────────────────────────────────────────────
+
+/**
+ * Export all LLM-merged distilled entries (with content) from the content store.
+ * Used by the GHA distillation pipeline to commit results back to the team repo.
+ * @param {string} [storePath]
+ * @returns {Array<Object>}
+ */
+function exportDistilled(storePath) {
+  const resolvedPath = storePath || contentStore.resolveStorePath();
+  const backend = contentStore.getBackend(resolvedPath);
+  const index = backend.loadIndex();
+  const distilledDir = path.join(resolvedPath, 'distilled');
+  const entries = [];
+
+  for (const [id, entry] of Object.entries(index.entries || {})) {
+    if (!entry.distilledFrom || !entry.distilledFrom.length) continue;
+
+    let content = null;
+    try {
+      content = fs.readFileSync(path.join(distilledDir, `${id}.md`), 'utf8');
+    } catch { /* content not persisted yet — skip */ }
+    if (!content) continue;
+
+    entries.push({
+      id,
+      date: entry.date,
+      repo: entry.repo,
+      title: entry.title,
+      content,
+      distill_tier: entry.distillTier,
+      distilled_from: entry.distilledFrom,
+      distilled_at: entry.distilledAt,
+      content_hash: entry.contentHash,
+      quality_score: entry.qualityScore || 3,
+      tags: entry.tags || [],
+    });
+  }
+
+  return entries;
+}
+
+/**
+ * Idempotently import distilled entries (from a team repo's distilled.json) into
+ * the local content store. Entries already present (by content_hash) are skipped.
+ * @param {Array<Object>} entries - Array of entries from exportDistilled()
+ * @param {string} [storePath]
+ * @returns {{ imported: number, skipped: number }}
+ */
+function importDistilled(entries, storePath) {
+  const resolvedPath = storePath || contentStore.resolveStorePath();
+  const backend = contentStore.getBackend(resolvedPath);
+  const index = backend.loadIndex();
+  const distilledDir = path.join(resolvedPath, 'distilled');
+
+  const existingHashes = new Set(
+    Object.values(index.entries || {}).map(e => e.contentHash).filter(Boolean)
+  );
+
+  let imported = 0;
+  let skipped = 0;
+
+  for (const entry of entries) {
+    if (existingHashes.has(entry.content_hash)) {
+      skipped++;
+      continue;
+    }
+
+    // Persist content file
+    try {
+      if (!fs.existsSync(distilledDir)) fs.mkdirSync(distilledDir, { recursive: true });
+      fs.writeFileSync(path.join(distilledDir, `${entry.id}.md`), entry.content || '', 'utf8');
+    } catch (writeErr) {
+      console.log(`  Warning: could not write content for ${entry.id}: ${writeErr.message}`);
+      continue;
+    }
+
+    index.entries[entry.id] = {
+      date: entry.date,
+      repo: entry.repo,
+      title: entry.title,
+      source: 'distilled',
+      user: '',
+      drifted: false,
+      contentHash: entry.content_hash,
+      contentLength: (entry.content || '').length,
+      tags: entry.tags || [],
+      hasEmbedding: false,
+      hasReasoning: true,
+      hasAlternatives: false,
+      qualityScore: entry.quality_score || 3,
+      distillTier: entry.distill_tier,
+      distilledFrom: entry.distilled_from,
+      distilledAt: entry.distilled_at,
+    };
+
+    existingHashes.add(entry.content_hash);
+    imported++;
+  }
+
+  if (imported > 0) {
+    index.entryCount = Object.keys(index.entries).length;
+    backend.saveIndex(index);
+  }
+
+  return { imported, skipped };
+}
+
 // ── Exports ─────────────────────────────────────────────────────────────────
 
 module.exports = {
@@ -351,5 +471,7 @@ module.exports = {
   deduplicateGroup,
   mergeEntries,
   titleSimilarity,
+  exportDistilled,
+  importDistilled,
   TIERS,
 };

package/bin/team-context.js

@@ -1366,6 +1366,45 @@ async function runReindex(args) {
 
 async function runDistill(args) {
   const distill = require('./distill');
+
+  // Sub-subcommands: export and import
+  const sub = args[0];
+
+  if (sub === 'export') {
+    const outputIdx = args.indexOf('--output');
+    const outputPath = outputIdx !== -1 ? args[outputIdx + 1] : null;
+    const entries = distill.exportDistilled();
+    const payload = JSON.stringify({ version: '1', generated_at: new Date().toISOString(), entries }, null, 2);
+    if (outputPath) {
+      const outDir = path.dirname(outputPath);
+      if (outDir && outDir !== '.') fs.mkdirSync(outDir, { recursive: true });
+      fs.writeFileSync(outputPath, payload, 'utf8');
+      console.log(`Exported ${entries.length} distilled entries → ${outputPath}`);
+    } else {
+      process.stdout.write(payload + '\n');
+    }
+    return;
+  }
+
+  if (sub === 'import') {
+    const filePath = args[1];
+    if (!filePath) {
+      console.error('Usage: wayfind distill import <path/to/distilled.json>');
+      process.exit(1);
+    }
+    let payload;
+    try {
+      payload = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch (err) {
+      console.error(`Could not read ${filePath}: ${err.message}`);
+      process.exit(1);
+    }
+    const entries = Array.isArray(payload) ? payload : (payload.entries || []);
+    const { imported, skipped } = distill.importDistilled(entries);
+    console.log(`Import complete: ${imported} new entries, ${skipped} already present`);
+    return;
+  }
+
   const dryRun = args.includes('--dry-run');
   const tierIdx = args.indexOf('--tier');
   const tier = (tierIdx !== -1 && args[tierIdx + 1]) ? args[tierIdx + 1] : 'daily';
@@ -3638,6 +3677,19 @@ async function contextPull(args) {
         }
       } catch (_) {}
     }
+    // Import distilled entries if the team repo has a distilled.json
+    const distilledJson = path.join(teamPath, '.wayfind', 'distilled.json');
+    if (fs.existsSync(distilledJson)) {
+      try {
+        const { importDistilled } = require('./distill');
+        const payload = JSON.parse(fs.readFileSync(distilledJson, 'utf8'));
+        const entries = Array.isArray(payload) ? payload : (payload.entries || []);
+        const { imported } = importDistilled(entries);
+        if (!quiet && imported > 0) {
+          log(`[wayfind] Imported ${imported} distilled entries from team repo`);
+        }
+      } catch (_) {}
+    }
   } else if (result.error && result.error.code === 'ETIMEDOUT') {
     log('[wayfind] Team-context pull timed out — using local state');
   } else {
@@ -5762,7 +5814,7 @@ const COMMANDS = {
               console.log(`\nUpdating ${containerName} (compose: ${composeDir})...`);
               const pullResult = spawnSync('docker', ['compose', 'pull'], { cwd: composeDir, stdio: 'inherit' });
               if (!pullResult.error && pullResult.status === 0) {
-                spawnSync('docker', ['compose', 'up', '-d'], { cwd: composeDir, stdio: 'inherit' });
+                spawnSync('docker', ['compose', 'up', '-d', '--force-recreate'], { cwd: composeDir, stdio: 'inherit' });
                 console.log(`${containerName} updated.`);
 
                 // Post-deploy smoke check

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wayfind",
-  "version": "2.0.53",
+  "version": "2.0.55",
   "description": "Team decision trail for AI-assisted development. The connective tissue between product, engineering, and strategy.",
   "bin": {
     "wayfind": "./bin/team-context.js",

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "wayfind",
-  "version": "2.0.53",
+  "version": "2.0.55",
   "description": "Team decision trail for AI-assisted development. Session memory, decision journals, and team digests.",
   "author": {
     "name": "Wayfind",

package/templates/gha-distill.yml

@@ -0,0 +1,72 @@
+# Wayfind distillation pipeline
+#
+# Copy this file to .github/workflows/wayfind-distill.yml in your team-context repo.
+#
+# What it does:
+#   - Runs on every push that touches journals/
+#   - Indexes all journals into a fresh content store
+#   - Runs the distillation pipeline (dedup + LLM merge for daily/weekly/archive tiers)
+#   - Exports distilled entries to .wayfind/distilled.json
+#   - Commits the result back to the repo
+#
+# Team members get the distilled entries automatically on their next `wayfind context pull`.
+#
+# Required secrets:
+#   ANTHROPIC_API_KEY  — for LLM merge calls during distillation
+#
+# Optional: set WAYFIND_DISTILL_TIER to 'daily', 'weekly', 'archive', or 'all' (default: all)
+
+name: Wayfind Distillation
+
+on:
+  push:
+    paths:
+      - 'journals/**'
+  workflow_dispatch:
+
+jobs:
+  distill:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install Wayfind
+        run: npm install -g wayfind
+
+      - name: Index journals
+        env:
+          TEAM_CONTEXT_STORE_PATH: ${{ github.workspace }}/.wayfind/store
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+        run: wayfind index-journals --dir ./journals --no-embeddings
+
+      - name: Distill
+        env:
+          TEAM_CONTEXT_STORE_PATH: ${{ github.workspace }}/.wayfind/store
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+        run: wayfind distill --tier ${{ vars.WAYFIND_DISTILL_TIER || 'all' }}
+
+      - name: Export distilled entries
+        env:
+          TEAM_CONTEXT_STORE_PATH: ${{ github.workspace }}/.wayfind/store
+        run: wayfind distill export --output .wayfind/distilled.json
+
+      - name: Commit distilled.json if changed
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add .wayfind/distilled.json
+          if git diff --cached --quiet; then
+            echo "No changes to distilled.json"
+          else
+            git commit -m "chore: update distilled context [skip ci]"
+            git push
+          fi