wayfind 2.0.31 → 2.0.33

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

@@ -3283,9 +3283,12 @@ async function runContext(args) {
     case 'default':
       contextSetDefault(subArgs);
       break;
+    case 'pull':
+      contextPull(subArgs);
+      break;
     default:
       console.error(`Unknown context subcommand: ${sub}`);
-      console.error('Available: init, sync, show, add, bind, list, default');
+      console.error('Available: init, sync, show, add, bind, list, default, pull');
       process.exit(1);
   }
 }
@@ -3428,6 +3431,61 @@ function contextSync() {
   console.log(`\nSynced ${synced} file(s) to .claude/context/`);
 }
 
+/**
+ * Pull latest from the team-context repo so session state reflects
+ * other engineers' recent work. Called by the session-start hook.
+ *
+ * Behavior:
+ *   - Pulls the team-context repo (journals, signals, shared context)
+ *   - Skips gracefully if offline, if pull fails, or if repo is dirty
+ *   - Does NOT touch the current working repo — devs handle that themselves
+ *   - Designed to run within the session-start hook's timeout
+ *
+ * @param {string[]} args - CLI arguments (--quiet suppresses output)
+ */
+function contextPull(args) {
+  const quiet = args.includes('--quiet');
+  const background = args.includes('--background');
+  const log = quiet ? () => {} : console.log;
+
+  const teamPath = getTeamContextPath();
+  if (!teamPath || !fs.existsSync(path.join(teamPath, '.git'))) {
+    if (!quiet) log('[wayfind] No team-context repo configured — skipping pull');
+    return;
+  }
+
+  const markerFile = path.join(teamPath, '.last-pull');
+
+  if (background) {
+    // Fire-and-forget — don't block session start
+    const child = require('child_process').spawn(
+      process.execPath,
+      [__filename, 'context', 'pull', '--quiet'],
+      { stdio: 'ignore', detached: true, env: { ...process.env } }
+    );
+    child.unref();
+    return;
+  }
+
+  const result = spawnSync('git', ['-C', teamPath, 'pull', '--rebase', '--autostash', '--quiet'], {
+    stdio: 'pipe',
+    timeout: 10000,
+  });
+
+  if (result.status === 0) {
+    log('[wayfind] Pulled latest team-context');
+    // Mark success — doctor checks this to warn on prolonged failures
+    try { fs.writeFileSync(markerFile, new Date().toISOString()); } catch {}
+  } else if (result.error && result.error.code === 'ETIMEDOUT') {
+    log('[wayfind] Team-context pull timed out — using local state');
+  } else {
+    const stderr = (result.stderr || '').toString().trim();
+    if (stderr && !quiet) {
+      console.error(`[wayfind] Team-context pull skipped: ${stderr.split('\n')[0]}`);
+    }
+  }
+}
+
 function contextShow() {
   const config = readContextConfig();
   const repoBinding = readRepoTeamBinding();
@@ -4312,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,
@@ -4324,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;
+      }
     }
   }
 
@@ -5001,8 +5072,9 @@ const COMMANDS = {
       }
       console.log('Sanitization passed — no proprietary content detected.');
 
-      // Show what changed
-      const diffResult = spawnSync('git', ['status', '--short'], { cwd: tmpDir, stdio: 'pipe' });
+      // Refresh git index so status detects copied files reliably
+      spawnSync('git', ['add', '-A'], { cwd: tmpDir, stdio: 'pipe' });
+      const diffResult = spawnSync('git', ['diff', '--cached', '--name-only'], { cwd: tmpDir, stdio: 'pipe' });
       const changes = (diffResult.stdout || '').toString().trim();
 
       if (!changes) {

package/doctor.sh

@@ -269,6 +269,54 @@ check_memory_files() {
     [ "$COUNT" -gt 0 ] && ok "$COUNT memory file(s) found" || info "No memory files yet"
 }
 
+check_team_context_freshness() {
+    echo ""
+    echo "Team context sync"
+
+    # Find team-context path via wayfind CLI
+    local TEAM_PATH=""
+    if [ -f "$HOME/repos/greg/wayfind/bin/team-context.js" ]; then
+        TEAM_PATH=$(node "$HOME/repos/greg/wayfind/bin/team-context.js" context show 2>/dev/null | grep 'Path:' | head -1 | sed 's/.*Path: *//' || true)
+    elif command -v wayfind >/dev/null 2>&1; then
+        TEAM_PATH=$(wayfind context show 2>/dev/null | grep 'Path:' | head -1 | sed 's/.*Path: *//' || true)
+    fi
+
+    if [ -z "$TEAM_PATH" ] || [ ! -d "$TEAM_PATH" ]; then
+        info "No team-context repo configured (optional)"
+        return
+    fi
+
+    local MARKER="$TEAM_PATH/.last-pull"
+    if [ ! -f "$MARKER" ]; then
+        # No pull has ever succeeded — check if this is a fresh install
+        # by looking at the git log age instead
+        local LAST_COMMIT
+        LAST_COMMIT=$(git -C "$TEAM_PATH" log -1 --format='%ci' 2>/dev/null || echo "")
+        if [ -z "$LAST_COMMIT" ]; then
+            info "Team-context repo exists but has no commits"
+        else
+            ok "Team-context configured (pull marker will appear after next session start)"
+        fi
+        return
+    fi
+
+    local PULL_TIME
+    PULL_TIME=$(cat "$MARKER")
+    local PULL_EPOCH
+    PULL_EPOCH=$(date -d "$PULL_TIME" +%s 2>/dev/null || date -j -f "%Y-%m-%dT%H:%M:%S" "${PULL_TIME%%.*}" +%s 2>/dev/null || echo 0)
+    local NOW_EPOCH
+    NOW_EPOCH=$(date +%s)
+    local AGE_HOURS=$(( (NOW_EPOCH - PULL_EPOCH) / 3600 ))
+
+    if [ "$AGE_HOURS" -gt 24 ]; then
+        warn "Team-context last pulled ${AGE_HOURS}h ago — other engineers' context may be stale"
+        info "Run: wayfind context pull"
+        ISSUES=$((ISSUES + 1))
+    else
+        ok "Team-context pulled ${AGE_HOURS}h ago"
+    fi
+}
+
 check_team_versions() {
     echo ""
     echo "Team version compliance"
@@ -309,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
@@ -330,6 +477,7 @@ echo "══════════════════════"
 check_hook_registered
 check_global_state
 check_backup
+check_team_context_freshness
 check_team_versions
 check_storage_backend
 check_memory_files

package/package.json

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

package/plugin/scripts/session-start.sh

@@ -25,6 +25,10 @@ if [ -z "$WAYFIND" ]; then
   exit 0
 fi
 
+# Pull latest team-context in the background so this session sees
+# other engineers' recent work without blocking session start
+$WAYFIND context pull --quiet --background 2>/dev/null || true
+
 # Rebuild Active Projects table (idempotent, concurrent-safe)
 $WAYFIND status --write --quiet 2>/dev/null || true