wayfind 2.0.41 → 2.0.44

package/bin/content-store.js

@@ -176,6 +176,27 @@ function isRepoExcluded(repo) {
   return false;
 }
 
+/**
+ * Check if a repo name matches a team scope pattern list.
+ * Patterns ending with '/' are prefix matches (e.g., 'acme/' matches 'acme/api', 'acme/frontend').
+ * All other patterns are exact matches.
+ * @param {string|null} repo
+ * @param {string[]} patterns
+ * @returns {boolean}
+ */
+function matchesTeamScope(repo, patterns) {
+  if (!patterns || patterns.length === 0) return true;
+  if (!repo) return false;
+  for (const p of patterns) {
+    if (p.endsWith('/')) {
+      if (repo.startsWith(p)) return true;
+    } else if (repo === p) {
+      return true;
+    }
+  }
+  return false;
+}
+
 // ── Journal parsing ─────────────────────────────────────────────────────────
 
 /**
@@ -432,6 +453,7 @@ async function indexJournals(options = {}) {
 
     for (const entry of entries) {
       if (isRepoExcluded(entry.repo)) continue;
+      if (options.repoAllowlist && !matchesTeamScope(entry.repo, options.repoAllowlist)) continue;
       const id = generateEntryId(date, entry.repo, entry.title);
       const author = entry.author || options.defaultAuthor || '';
       const content = buildContent({ ...entry, date, author });
@@ -2290,6 +2312,47 @@ function deduplicateResults(results) {
   return results.filter(r => !absorbedIds.has(r.id));
 }
 
+/**
+ * Remove entries from a store whose repo doesn't match the allowed patterns.
+ * Trims both index and embeddings. Safe to call repeatedly (idempotent).
+ * @param {string} storePath
+ * @param {string[]} allowedPatterns - prefix patterns (ending '/') or exact names
+ * @returns {{ kept: number, removed: number, removedRepos: string[] }}
+ */
+async function trimStore(storePath, allowedPatterns) {
+  if (!allowedPatterns || allowedPatterns.length === 0) {
+    throw new Error('allowedPatterns is required — refusing to trim to empty set');
+  }
+  const backend = getBackend(storePath);
+  const idx = backend.loadIndex();
+  const embeddings = backend.loadEmbeddings() || {};
+
+  const keptEntries = {};
+  const keptEmbeddings = {};
+  const removedRepos = [];
+
+  for (const [id, entry] of Object.entries(idx.entries || {})) {
+    if (matchesTeamScope(entry.repo, allowedPatterns)) {
+      keptEntries[id] = entry;
+      if (embeddings[id]) keptEmbeddings[id] = embeddings[id];
+    } else {
+      removedRepos.push(entry.repo);
+    }
+  }
+
+  idx.entries = keptEntries;
+  idx.entryCount = Object.keys(keptEntries).length;
+  idx.lastUpdated = new Date().toISOString();
+  backend.saveIndex(idx);
+  backend.saveEmbeddings(keptEmbeddings);
+
+  return {
+    kept: idx.entryCount,
+    removed: removedRepos.length,
+    removedRepos: [...new Set(removedRepos)].sort(),
+  };
+}
+
 module.exports = {
   // Parsing
   parseJournalFile,
@@ -2318,8 +2381,12 @@ module.exports = {
 
   // Filtering
   isRepoExcluded,
+  matchesTeamScope,
   applyFilters,
 
+  // Store maintenance
+  trimStore,
+
   // Quality & dedup
   computeQualityScore,
   deduplicateResults,

package/bin/team-context.js

@@ -1111,8 +1111,16 @@ async function runIndexJournals(args) {
   const journalDir = opts.dir || contentStore.DEFAULT_JOURNAL_DIR;
   const storePath = opts.store || contentStore.resolveStorePath();
 
+  // Load team scope allowlist from context.json — only index repos bound to the active team.
+  const ctxConfig = readContextConfig();
+  const teamId = readRepoTeamBinding() || ctxConfig.default;
+  const teamConfig = teamId && ctxConfig.teams && ctxConfig.teams[teamId];
+  const repoAllowlist = (teamConfig && teamConfig.bound_repos && teamConfig.bound_repos.length > 0)
+    ? teamConfig.bound_repos : undefined;
+
   console.log(`Indexing journals from: ${journalDir}`);
   console.log(`Store: ${storePath}`);
+  if (repoAllowlist) console.log(`Team scope (${teamId}): ${repoAllowlist.join(', ')}`);
   console.log('');
 
   try {
@@ -1120,6 +1128,7 @@ async function runIndexJournals(args) {
       journalDir,
       storePath,
       embeddings: opts.noEmbeddings ? false : undefined,
+      repoAllowlist,
     });
 
     console.log(`Indexed: ${stats.entryCount} entries`);
@@ -3591,6 +3600,21 @@ function contextBind(args) {
   writeRepoTeamBinding(teamId);
   console.log(`Bound this repo to: ${config.teams[teamId].name} (${teamId})`);
   console.log('Journals from this repo will sync to that team\'s context repo.');
+
+  // Derive repo label (e.g., "acme/api") and add to the team's bound_repos allowlist.
+  const cwdParts = process.cwd().split(path.sep);
+  const reposIdx = cwdParts.lastIndexOf('repos');
+  const repoLabel = (reposIdx >= 0 && reposIdx + 2 <= cwdParts.length)
+    ? cwdParts.slice(reposIdx + 1).join('/')
+    : cwdParts[cwdParts.length - 1];
+
+  const team = config.teams[teamId];
+  if (!team.bound_repos) team.bound_repos = [];
+  if (!team.bound_repos.includes(repoLabel)) {
+    team.bound_repos.push(repoLabel);
+    writeContextConfig(config);
+    console.log(`Added "${repoLabel}" to team scope.`);
+  }
 }
 
 function contextList() {
@@ -5000,6 +5024,52 @@ async function runContainerDoctor() {
   }
 }
 
+// ── Store management ────────────────────────────────────────────────────────
+
+async function runStoreTrim(args) {
+  const ctxConfig = readContextConfig();
+  const teamId = args[0] || readRepoTeamBinding() || ctxConfig.default;
+  if (!teamId) {
+    console.error('No team ID resolved. Usage: wayfind store trim [team-id]');
+    process.exit(1);
+  }
+  const team = ctxConfig.teams && ctxConfig.teams[teamId];
+  if (!team) {
+    console.error(`Team "${teamId}" not found.`);
+    process.exit(1);
+  }
+  const allowedPatterns = team.bound_repos;
+  if (!allowedPatterns || allowedPatterns.length === 0) {
+    console.error(`Team "${teamId}" has no bound_repos in context.json. Configure them first.`);
+    process.exit(1);
+  }
+  const storePath = contentStore.resolveStorePath(teamId);
+  console.log(`Team:     ${team.name} (${teamId})`);
+  console.log(`Store:    ${storePath}`);
+  console.log(`Patterns: ${allowedPatterns.join(', ')}`);
+  console.log('');
+  const stats = await contentStore.trimStore(storePath, allowedPatterns);
+  console.log(`Kept:    ${stats.kept}`);
+  console.log(`Removed: ${stats.removed}`);
+  if (stats.removedRepos.length > 0) {
+    console.log(`Repos removed:`);
+    stats.removedRepos.forEach(r => console.log(`  ${r}`));
+  }
+}
+
+async function runStore(args) {
+  const [sub, ...subArgs] = args;
+  switch (sub) {
+    case 'trim':
+      await runStoreTrim(subArgs);
+      break;
+    default:
+      console.error(`Unknown store subcommand: ${sub || ''}`);
+      console.error('Available: trim');
+      process.exit(1);
+  }
+}
+
 // ── Command registry ────────────────────────────────────────────────────────
 
 const COMMANDS = {
@@ -5274,6 +5344,10 @@ const COMMANDS = {
     desc: 'Scaffold Docker deployment in your team context repo',
     run: (args) => runDeploy(args),
   },
+  store: {
+    desc: 'Manage content store (trim)',
+    run: (args) => runStore(args),
+  },
   onboard: {
     desc: 'Generate an onboarding context pack for a repo',
     run: (args) => runOnboard(args),

package/doctor.sh

@@ -363,16 +363,45 @@ check_storage_backend() {
         info "TEAM_CONTEXT_STORAGE_BACKEND=$TEAM_CONTEXT_STORAGE_BACKEND (env override)"
     fi
 
-    local WAYFIND_DIR="${WAYFIND_DIR:-$HOME/.claude/team-context}"
     local SCRIPT_DIR
     SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
+    # Resolve the team-scoped store path (respects .claude/wayfind.json + context.json default)
+    local RESOLVED_STORE ACTIVE_TEAM_ID
+    RESOLVED_STORE=$(node -e "
+      try {
+        const cs = require('$SCRIPT_DIR/bin/content-store.js');
+        console.log(cs.resolveStorePath());
+      } catch (e) {
+        console.log('SKIP:' + e.message.split('\n')[0]);
+      }
+    " 2>/dev/null) || RESOLVED_STORE="SKIP:content-store not available"
+    ACTIVE_TEAM_ID=$(node -e "
+      try {
+        const cs = require('$SCRIPT_DIR/bin/content-store.js');
+        // resolveStorePath triggers team ID resolution; extract from path
+        const p = cs.resolveStorePath();
+        const m = p && p.match(/teams\/([^/]+)\/content-store/);
+        console.log(m ? m[1] : 'default');
+      } catch (e) {
+        console.log('unknown');
+      }
+    " 2>/dev/null) || ACTIVE_TEAM_ID="unknown"
+
+    if [[ "$RESOLVED_STORE" != SKIP:* ]]; then
+        ok "Active team: $ACTIVE_TEAM_ID"
+        info "Store path: $RESOLVED_STORE"
+    fi
+
+    local WAYFIND_DIR="${WAYFIND_DIR:-$HOME/.claude/team-context}"
+
     # ── 1. Which backend is active ───────────────────────────────────────────
     local BACKEND_RESULT=""
     BACKEND_RESULT=$(node -e "
       try {
+        const cs = require('$SCRIPT_DIR/bin/content-store.js');
         const storage = require('$SCRIPT_DIR/bin/storage/index.js');
-        const storePath = '$WAYFIND_DIR';
+        const storePath = cs.resolveStorePath();
         storage.getBackend(storePath);
         const info = storage.getBackendInfo(storePath);
         if (!info) { console.log('NONE'); process.exit(0); }
@@ -472,8 +501,9 @@ check_storage_backend() {
     local EMBED_RESULT
     EMBED_RESULT=$(node -e "
       try {
+        const cs = require('$SCRIPT_DIR/bin/content-store.js');
         const storage = require('$SCRIPT_DIR/bin/storage/index.js');
-        const storePath = '$WAYFIND_DIR/content-store';
+        const storePath = cs.resolveStorePath();
         const backend = storage.getBackend(storePath);
         const idx = backend.loadIndex();
         if (!idx || !idx.entries) { console.log('SKIP'); process.exit(0); }

package/package.json

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

package/setup.sh

@@ -441,48 +441,6 @@ PYEOF
             fi
         fi
 
-        # Status line script
-        STATUSLINE_DEST="$HOME/.claude/team-context/statusline.sh"
-        if [ ! -f "$STATUSLINE_DEST" ] || [ "$UPDATE" = true ]; then
-            run cp "$SCRIPT_DIR/templates/statusline.sh" "$STATUSLINE_DEST"
-            run chmod +x "$STATUSLINE_DEST"
-            log "Installed status line: $STATUSLINE_DEST"
-        else
-            info "Status line already exists: $STATUSLINE_DEST — skipped"
-        fi
-
-        # Merge statusLine config into settings.json
-        if [ -f "$SETTINGS" ] && ! grep -q "statusLine" "$SETTINGS" 2>/dev/null; then
-            if [ "$DRY_RUN" = false ]; then
-                TMP_SL="$(mktemp)"
-                if python3 - "$SETTINGS" "$STATUSLINE_DEST" "$TMP_SL" <<'PYEOF' 2>/dev/null; then
-import json, sys
-settings_path, sl_cmd, out_path = sys.argv[1], sys.argv[2], sys.argv[3]
-try:
-    with open(settings_path) as f:
-        settings = json.load(f)
-except (json.JSONDecodeError, IOError):
-    sys.exit(1)
-if "statusLine" not in settings:
-    settings["statusLine"] = {"type": "command", "command": sl_cmd, "padding": 2}
-with open(out_path, "w") as f:
-    json.dump(settings, f, indent=2)
-    f.write("\n")
-PYEOF
-                    mv "$TMP_SL" "$SETTINGS"
-                    log "Added statusLine config to $SETTINGS"
-                else
-                    rm -f "$TMP_SL"
-                    warn "Could not add statusLine to $SETTINGS (malformed JSON or python3 unavailable)"
-                fi
-            else
-                info "[dry-run] Would add statusLine to $SETTINGS"
-            fi
-        else
-            if [ -f "$SETTINGS" ]; then
-                info "statusLine already configured in settings.json — skipped"
-            fi
-        fi
         ;;
 
     cursor)