wayfind 2.0.32 → 2.0.34

package/bin/content-store.js

@@ -569,8 +569,38 @@ function searchText(query, options = {}) {
       ...(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 || DEFAULT_SIGNALS_DIR;
+      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 = getJournalContent(entry.date, entry.user);
+    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.

package/bin/storage/index.js

@@ -126,7 +126,9 @@ function getBackend(storePath) {
     migrateFromJson(backend, storePath);
     cache[storePath] = backend;
     return backend;
-  } catch {
+  } catch (err) {
+    console.error('Warning: SQLite backend failed to initialize, falling back to JSON.', err.message);
+    cache[storePath + ':fallback'] = true;
     const backend = new JsonBackend(storePath);
     backend.open();
     cache[storePath] = backend;
@@ -164,8 +166,23 @@ function getBackendType(storePath) {
   return null;
 }
 
+/**
+ * Returns detailed backend info including whether it was a silent fallback.
+ *
+ * @param {string} storePath
+ * @returns {{ type: 'sqlite'|'json'|'unknown', storePath: string, fallback: boolean }|null}
+ */
+function getBackendInfo(storePath) {
+  const backend = cache[storePath];
+  if (!backend) return null;
+  const type = backend instanceof JsonBackend ? 'json' :
+    (backend.constructor && backend.constructor.name === 'SqliteBackend') ? 'sqlite' : 'unknown';
+  return { type, storePath, fallback: !!cache[storePath + ':fallback'] };
+}
+
 module.exports = {
   getBackend,
   clearCache,
   getBackendType,
+  getBackendInfo,
 };

package/bin/team-context.js

@@ -4370,10 +4370,10 @@ function ensureContainerConfig() {
     }
   }
 
-  // GitHub connector
-  if (!config.github && process.env.GITHUB_TOKEN) {
+  // GitHub connector — create if missing, or fix transport if mounted config has gh-cli
+  if (process.env.GITHUB_TOKEN) {
     const repos = process.env.TEAM_CONTEXT_GITHUB_REPOS;
-    if (repos) {
+    if (!config.github && repos) {
       config.github = {
         transport: 'https',
         token: process.env.GITHUB_TOKEN,
@@ -4382,6 +4382,19 @@ function ensureContainerConfig() {
         last_pull: null,
       };
       changed = true;
+    } else if (config.github) {
+      // Override gh-cli transport in container context — gh binary isn't available
+      if (config.github.transport === 'gh-cli') {
+        config.github.transport = 'https';
+        config.github.token = process.env.GITHUB_TOKEN;
+        config.github.token_env = 'GITHUB_TOKEN';
+        changed = true;
+      }
+      // Backfill repos from env if config has none or env specifies them
+      if (repos && (!config.github.repos || config.github.repos.length === 0)) {
+        config.github.repos = repos.split(',').map((r) => r.trim());
+        changed = true;
+      }
     }
   }
 

package/doctor.sh

@@ -357,17 +357,116 @@ check_storage_backend() {
     echo ""
     echo "Storage backend"
 
+    set +e  # Temporarily disable errexit — node calls may fail in test environments
     # Check for env var override
     if [ -n "${TEAM_CONTEXT_STORAGE_BACKEND:-}" ]; then
         info "TEAM_CONTEXT_STORAGE_BACKEND=$TEAM_CONTEXT_STORAGE_BACKEND (env override)"
     fi
 
-    # Check if better-sqlite3 is available
-    if node -e "require('better-sqlite3')" 2>/dev/null; then
-        ok "Storage backend: sqlite (better-sqlite3 available)"
+    local WAYFIND_DIR="${WAYFIND_DIR:-$HOME/.claude/team-context}"
+    local SCRIPT_DIR
+    SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+    # ── 1. Which backend is active ───────────────────────────────────────────
+    local BACKEND_RESULT=""
+    BACKEND_RESULT=$(node -e "
+      try {
+        const storage = require('$SCRIPT_DIR/bin/storage/index.js');
+        const storePath = '$WAYFIND_DIR';
+        storage.getBackend(storePath);
+        const info = storage.getBackendInfo(storePath);
+        if (!info) { console.log('NONE'); process.exit(0); }
+        console.log(JSON.stringify(info));
+      } catch (e) {
+        console.log('SKIP:' + e.message.split('\n')[0]);
+      }
+    " 2>/dev/null) || BACKEND_RESULT="SKIP:storage module not available"
+
+    if [[ "$BACKEND_RESULT" == SKIP:* ]]; then
+        [ "$VERBOSE" = true ] && info "Storage check skipped: ${BACKEND_RESULT#SKIP:}"
+    elif [[ "$BACKEND_RESULT" == "NONE" ]]; then
+        info "No storage backend initialized (team-context not configured)"
+    else
+        local BACKEND_TYPE
+        BACKEND_TYPE=$(echo "$BACKEND_RESULT" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')); console.log(d.type)" 2>/dev/null || echo "unknown")
+        local IS_FALLBACK
+        IS_FALLBACK=$(echo "$BACKEND_RESULT" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')); console.log(d.fallback)" 2>/dev/null || echo "false")
+
+        if [ "$BACKEND_TYPE" = "sqlite" ]; then
+            ok "Active backend: sqlite"
+        elif [ "$BACKEND_TYPE" = "json" ]; then
+            ok "Active backend: json"
+        else
+            warn "Active backend: $BACKEND_TYPE (unexpected)"
+        fi
+
+        # ── 2. Fallback detection ────────────────────────────────────────────
+        if [ "$IS_FALLBACK" = "true" ]; then
+            warn "JSON backend is a fallback — better-sqlite3 was expected but failed to load"
+            info "Run: npm install -g better-sqlite3  (or reinstall wayfind)"
+            ISSUES=$((ISSUES + 1))
+        elif [ "$BACKEND_TYPE" = "json" ]; then
+            # Not a runtime fallback — check if sqlite3 is available but unused
+            if node -e "require('better-sqlite3')" 2>/dev/null; then
+                warn "better-sqlite3 is installed but backend is JSON — possible unexpected fallback"
+                info "Check TEAM_CONTEXT_STORAGE_BACKEND env var or re-run setup"
+                ISSUES=$((ISSUES + 1))
+            else
+                [ "$VERBOSE" = true ] && info "better-sqlite3 not installed — JSON is expected"
+            fi
+        fi
+    fi
+
+    # ── 3. Signal freshness (connectors.json last_pull) ──────────────────────
+    local CONNECTORS="$WAYFIND_DIR/connectors.json"
+    if [ -f "$CONNECTORS" ]; then
+        local FRESHNESS_RESULT
+        FRESHNESS_RESULT=$(node -e "
+          const fs = require('fs');
+          const config = JSON.parse(fs.readFileSync('$CONNECTORS', 'utf8'));
+          const connectors = ['github', 'intercom', 'notion'];
+          const now = Date.now();
+          const DAY = 24 * 60 * 60 * 1000;
+          const results = [];
+          for (const name of connectors) {
+            const c = config[name];
+            if (!c) continue;
+            const lp = c.last_pull;
+            if (!lp) {
+              results.push('WARN:' + name + ':never pulled');
+            } else {
+              const age = now - new Date(lp).getTime();
+              const hours = Math.floor(age / (60 * 60 * 1000));
+              if (age > DAY) {
+                results.push('WARN:' + name + ':' + hours + 'h ago');
+              } else {
+                results.push('OK:' + name + ':' + hours + 'h ago');
+              }
+            }
+          }
+          console.log(results.join('|'));
+        " 2>/dev/null) || FRESHNESS_RESULT=""
+
+        if [ -n "$FRESHNESS_RESULT" ]; then
+            IFS='|' read -ra ENTRIES <<< "$FRESHNESS_RESULT"
+            for entry in "${ENTRIES[@]}"; do
+                local STATUS="${entry%%:*}"
+                local REST="${entry#*:}"
+                local NAME="${REST%%:*}"
+                local DETAIL="${REST#*:}"
+                if [ "$STATUS" = "WARN" ]; then
+                    warn "Signal $NAME: $DETAIL"
+                    info "Run: wayfind pull $NAME"
+                    ISSUES=$((ISSUES + 1))
+                else
+                    ok "Signal $NAME: last pull $DETAIL"
+                fi
+            done
+        fi
     else
-        ok "Storage backend: json (better-sqlite3 not installed — using JSON fallback)"
+        [ "$VERBOSE" = true ] && info "No connectors.json — signal freshness check skipped"
     fi
+    set -e  # Restore errexit
 }
 
 # Run checks

package/package.json

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