wayfind 2.0.47 → 2.0.49

package/bin/intelligence.js

@@ -59,6 +59,10 @@ function splitAndLabel(content, startId) {
  * @param {Object} llmConfig - LLM config for the scoring call
  * @returns {Promise<Array<{id: number, [personaId]: number}>|null>} Scores array or null on failure
  */
+// Maximum characters to send to the scoring LLM in a single call.
+// Beyond this, scoring is skipped and budget truncation handles content selection.
+const SCORE_MAX_CHARS = 40000;
+
 async function scoreItems(signalContent, journalContent, personas, llmConfig) {
   const signalResult = splitAndLabel(signalContent, 0);
   const journalResult = splitAndLabel(journalContent, signalResult.items.length);
@@ -66,6 +70,11 @@ async function scoreItems(signalContent, journalContent, personas, llmConfig) {
   const totalItems = signalResult.items.length + journalResult.items.length;
   if (totalItems === 0) return null;
 
+  // Skip scoring if content is too large for a reliable single LLM call.
+  // The token budget step will handle content selection without scoring.
+  const totalChars = (signalResult.labeled || '').length + (journalResult.labeled || '').length;
+  if (totalChars > SCORE_MAX_CHARS) return null;
+
   const systemPrompt = buildScoringPrompt(personas);
 
   const userParts = [];

package/bin/team-context.js

@@ -327,28 +327,134 @@ async function teamCreate() {
 }
 
 async function teamJoin(args) {
-  const teamId = args[0];
+  const input = args[0];
+  if (!input) {
+    console.error('Error: repo URL or path is required.');
+    console.error('Usage: wayfind team join <repo-url-or-path>');
+    console.error('Example: wayfind team join https://github.com/acme/team-context');
+    process.exit(1);
+  }
+
+  // Determine if input is a URL to clone or a local path
+  const isUrl = /^https?:\/\/|^git@|^github\.com\//.test(input);
+  let repoPath;
+
+  if (isUrl) {
+    // Parse org/repo from URL for clone destination suggestion
+    const urlMatch = input.match(/[:/]([^/]+)\/([^/.]+?)(?:\.git)?$/);
+    if (!urlMatch) {
+      console.error(`Could not parse org/repo from URL: ${input}`);
+      process.exit(1);
+    }
+    const [, org, repo] = urlMatch;
+    const orgDir = path.join(HOME, 'repos', org);
+    const suggested = fs.existsSync(orgDir)
+      ? path.join(orgDir, repo)
+      : path.join(HOME, '.claude', 'team-context', repo);
+
+    let dest = suggested;
+    if (fs.existsSync(suggested)) {
+      console.log(`\nRepo already cloned at: ${suggested}`);
+      const useExisting = await ask(`Use existing clone? [Y/n]: `);
+      if (useExisting.toLowerCase() === 'n') {
+        const custom = await ask(`Clone to [${suggested}]: `);
+        dest = custom ? path.resolve(custom.replace(/^~/, HOME)) : suggested;
+      }
+    } else {
+      const confirm = await ask(`\nClone to ${suggested}? [Y/n]: `);
+      if (confirm.toLowerCase() === 'n') {
+        const custom = await ask(`Clone to: `);
+        if (!custom) { console.error('Destination required.'); process.exit(1); }
+        dest = path.resolve(custom.replace(/^~/, HOME));
+      }
+      console.log(`Cloning ${input}...`);
+      const cloneUrl = /^https?:\/\//.test(input) ? input : `https://${input}`;
+      const result = spawnSync('git', ['clone', cloneUrl, dest], { stdio: 'inherit' });
+      if (result.status !== 0) {
+        console.error('Clone failed.');
+        process.exit(1);
+      }
+    }
+    repoPath = dest;
+  } else {
+    repoPath = path.resolve(input.replace(/^~/, HOME));
+    if (!fs.existsSync(repoPath)) {
+      console.error(`Directory not found: ${repoPath}`);
+      process.exit(1);
+    }
+  }
+
+  // Read wayfind.json from the repo
+  const sharedConfig = readJSONFile(path.join(repoPath, 'wayfind.json')) || {};
+  const teamId = sharedConfig.team_id;
   if (!teamId) {
-    console.error('Error: team ID is required.');
-    console.error('Usage: wayfind team join <team-id>');
+    console.error('');
+    console.error(`Error: wayfind.json in that repo has no team_id.`);
+    console.error('Ask your team admin to run:');
+    console.error(`  wayfind context add <team-id> ${repoPath}`);
     process.exit(1);
   }
+  const teamName = sharedConfig.team_name || teamId;
+  const containerEndpoint = sharedConfig.container_endpoint || null;
 
-  const team = {
-    teamId,
-    joined: new Date().toISOString(),
+  // Register in local context.json
+  const config = readContextConfig();
+  if (!config.teams) config.teams = {};
+  const existing = config.teams[teamId];
+  config.teams[teamId] = {
+    path: repoPath,
+    name: teamName,
+    configured_at: new Date().toISOString(),
+    ...(containerEndpoint ? { container_endpoint: containerEndpoint } : {}),
+    ...(existing && existing.bound_repos ? { bound_repos: existing.bound_repos } : {}),
   };
+  if (!config.default) config.default = teamId;
+  writeContextConfig(config);
 
-  writeJSONFile(TEAM_FILE, team);
+  // Check API key status
+  const keyFile = path.join(repoPath, '.wayfind-api-key');
+  const keyReady = fs.existsSync(keyFile) && (() => {
+    try { return fs.readFileSync(keyFile, 'utf8').trim().length >= 32; } catch { return false; }
+  })();
+
+  // Print confirmation
   console.log('');
-  console.log(`Joined team ${teamId}.`);
+  console.log(`Joined team '${teamName}' (${teamId})`);
+  console.log(`  Repo:             ${repoPath}`);
+  if (containerEndpoint) {
+    console.log(`  Semantic search:  available  |  ${containerEndpoint}`);
+  } else {
+    console.log(`  Semantic search:  not configured`);
+    console.log(`                    Ask your team admin: wayfind deploy set-endpoint <url> --team ${teamId}`);
+  }
+  if (keyReady) {
+    console.log(`  Search API key:   ready — rotates daily, committed to team repo`);
+  } else {
+    console.log(`  Search API key:   pending — will appear after the container's first key rotation`);
+    console.log(`                    Run \`git pull\` in ${repoPath} after the container starts`);
+  }
+  console.log('');
+  console.log('How the search key works:');
+  console.log('  The container rotates this key every 24 hours and commits it to the team repo.');
+  console.log('  Your Claude Code sessions read the latest key automatically from the cloned repo.');
+  console.log('  You never need to manage it — just keep the repo up to date (git pull).');
+  console.log('');
+  console.log('Next: bind your repos to this team with:');
+  console.log(`  wayfind context bind ${teamId}   (run from each repo you work in)`);
+
+  if (existing) {
+    console.log('');
+    console.log(`  (Updated existing registration for team ${teamId})`);
+  }
 
+  // Register profile in team directory
   const profile = readJSONFile(PROFILE_FILE);
   if (profile) {
     syncMemberToRegistry(profile, teamId);
     await announceToSlack(profile, teamId);
   } else {
-    console.log("  Run 'wayfind whoami --setup' to register in the team directory.");
+    console.log('');
+    console.log("Run 'wayfind whoami --setup' to register your profile in the team directory.");
   }
   console.log('');
 }
@@ -947,12 +1053,26 @@ async function runDigest(args) {
     process.exit(1);
   }
 
+  // Sanitize configured paths — connectors.json may have been written from inside a container
+  // with paths like /home/node/... or /data/... that don't exist on the host. Fall back to
+  // local defaults for any path that doesn't resolve on this machine.
+  const digestConfig = { ...config.digest };
+  if (digestConfig.store_path && !fs.existsSync(digestConfig.store_path)) {
+    digestConfig.store_path = contentStore.resolveStorePath();
+  }
+  if (digestConfig.journal_dir && !fs.existsSync(digestConfig.journal_dir)) {
+    digestConfig.journal_dir = contentStore.DEFAULT_JOURNAL_DIR;
+  }
+  if (digestConfig.signals_dir && !fs.existsSync(digestConfig.signals_dir)) {
+    digestConfig.signals_dir = contentStore.resolveSignalsDir();
+  }
+
   // Generate digests
   console.log(`Generating digests for: ${personaIds.join(', ')}`);
   console.log(`Period: ${sinceDate} to today`);
   console.log('');
 
-  const result = await digest.generateDigest(config.digest, personaIds, sinceDate, (progress) => {
+  const result = await digest.generateDigest(digestConfig, personaIds, sinceDate, (progress) => {
     if (progress.phase === 'start') {
       process.stdout.write(`  ${progress.personaId} (${progress.index + 1}/${progress.total})... `);
     } else if (progress.phase === 'done') {
@@ -2033,6 +2153,15 @@ function journalSync(args) {
     teamFiles[teamId].push({ file, srcPath: path.join(journalDir, file) });
   }
 
+  // Always update member version stamp for all registered teams, even if no files to sync.
+  // This ensures the stamp stays current regardless of whether journals are flowing.
+  if (config.teams) {
+    for (const teamId of Object.keys(config.teams)) {
+      const teamPath = getTeamContextPath(teamId);
+      if (teamPath) stampMemberVersion(teamPath);
+    }
+  }
+
   if (Object.keys(teamFiles).length === 0) {
     console.log('No journal files to sync.');
     return;
@@ -3549,9 +3678,20 @@ function contextAdd(args) {
   const config = readContextConfig();
   if (!config.teams) config.teams = {};
 
-  // Try to read team name from the repo's wayfind.json
-  const sharedConfig = readJSONFile(path.join(resolved, 'wayfind.json')) || {};
+  // Read and update wayfind.json in the repo — write team_id/team_name so joiners
+  // can read them without needing to know the ID out of band
+  const sharedConfigPath = path.join(resolved, 'wayfind.json');
+  const sharedConfig = readJSONFile(sharedConfigPath) || {};
   const teamName = sharedConfig.team_name || teamId;
+  if (!sharedConfig.team_id || !sharedConfig.team_name) {
+    sharedConfig.team_id = teamId;
+    sharedConfig.team_name = teamName;
+    try {
+      fs.writeFileSync(sharedConfigPath, JSON.stringify(sharedConfig, null, 2) + '\n');
+    } catch (err) {
+      console.error(`Warning: could not write wayfind.json: ${err.message}`);
+    }
+  }
 
   config.teams[teamId] = {
     path: resolved,
@@ -3566,6 +3706,23 @@ function contextAdd(args) {
   if (Object.keys(config.teams).length === 1) {
     console.log('  Set as default (only team).');
   }
+
+  // Generate first search API key if one doesn't exist yet
+  const keyFile = path.join(resolved, '.wayfind-api-key');
+  if (!fs.existsSync(keyFile)) {
+    const key = crypto.randomBytes(32).toString('hex');
+    try {
+      fs.writeFileSync(keyFile, key + '\n', 'utf8');
+      // Resolve token for git push (CLI context — use gh CLI)
+      const token = detectGitHubToken();
+      if (token && !process.env.GITHUB_TOKEN) process.env.GITHUB_TOKEN = token;
+      pushApiKey(resolved);
+      console.log('  Generated initial search API key → committed to team repo.');
+      console.log('  Teammates who join will read it automatically. It rotates daily.');
+    } catch (err) {
+      console.error(`  Warning: could not generate API key: ${err.message}`);
+    }
+  }
 }
 
 function contextBind(args) {
@@ -3899,7 +4056,8 @@ function deployTeamInit(teamId, { port } = {}) {
   let composeContent = fs.readFileSync(templatePath, 'utf8');
   composeContent = composeContent
     .replace(/container_name: wayfind/, `container_name: ${containerName}`)
-    .replace(/- "3141:3141"/, `- "${assignedPort}:3141"`);
+    .replace(/- "3141:3141"/, `- "${assignedPort}:3141"`)
+    .replace(/^(services:)/m, `name: ${containerName}\n\n$1`);
 
   // Inject Docker label for discovery
   composeContent = composeContent.replace(
@@ -4690,7 +4848,7 @@ async function indexJournalsIfAvailable() {
     console.log('No journal files found — skipping index.');
     return;
   }
-  const hasEmbeddingKey = !!process.env.OPENAI_API_KEY;
+  const hasEmbeddingKey = !!(process.env.OPENAI_API_KEY || process.env.AZURE_OPENAI_EMBEDDING_ENDPOINT);
   console.log(`Indexing ${entries.length} journal files from ${journalDir}${hasEmbeddingKey ? ' (with embeddings)' : ''}...`);
   try {
     const stats = await contentStore.indexJournals({
@@ -5767,6 +5925,21 @@ const COMMANDS = {
       // Also sync public-staging docs if they exist
       const publicDocsDir = path.join(sourceRoot, 'public-staging', 'docs');
 
+      // Keep plugin.json version in sync with package.json before syncing
+      const pluginJsonPath = path.join(sourceRoot, 'plugin', '.claude-plugin', 'plugin.json');
+      const pkgJsonPath = path.join(sourceRoot, 'package.json');
+      if (fs.existsSync(pluginJsonPath) && fs.existsSync(pkgJsonPath)) {
+        try {
+          const pluginJson = JSON.parse(fs.readFileSync(pluginJsonPath, 'utf8'));
+          const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+          if (pluginJson.version !== pkgJson.version) {
+            pluginJson.version = pkgJson.version;
+            fs.writeFileSync(pluginJsonPath, JSON.stringify(pluginJson, null, 2) + '\n');
+            console.log(`Updated plugin.json version to ${pkgJson.version}`);
+          }
+        } catch {}
+      }
+
       console.log('Syncing files...');
       for (const item of syncItems) {
         const isDir = item.endsWith('/');
@@ -5932,8 +6105,8 @@ function showHelp() {
   console.log('  /doctor                        Check installation health');
   console.log('');
   console.log('Team setup:');
-  console.log('  wayfind team create           Create a new team');
-  console.log('  wayfind team join <id>        Join an existing team');
+  console.log('  wayfind team create                    Create a new team');
+  console.log('  wayfind team join <repo-url-or-path>  Join an existing team');
   console.log('  wayfind team status           Show current team info');
   console.log('  wayfind whoami                Show your profile');
   console.log('  wayfind whoami --setup        Set up your profile and personas');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wayfind",
-  "version": "2.0.47",
+  "version": "2.0.49",
   "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.20",
+  "version": "2.0.48",
   "description": "Team decision trail for AI-assisted development. Session memory, decision journals, and team digests.",
   "author": {
     "name": "Wayfind",

package/plugin/scripts/session-end.sh

@@ -37,7 +37,8 @@ LAST_RUN_FILE="$HOME/.claude/team-context/.last-reindex"
 if [ -f "$LAST_RUN_FILE" ]; then
   CHANGED=$(find "$HOME/.claude/projects" -name "*.jsonl" -newer "$LAST_RUN_FILE" -print -quit 2>/dev/null)
   if [ -z "$CHANGED" ]; then
-    # No conversation files changed — skip expensive reindex, just sync journals
+    # No conversation files changed — skip expensive reindex, just split and sync journals
+    $WAYFIND journal split 2>/dev/null
     $WAYFIND journal sync 2>/dev/null &
     exit 0
   fi
@@ -50,5 +51,6 @@ $WAYFIND reindex --conversations-only --export --detect-shifts --write-stats 2>/
 mkdir -p "$HOME/.claude/team-context"
 touch "$LAST_RUN_FILE"
 
-# Sync authored journals to team-context repo (backgrounded)
+# Split any unsuffixed journals, then sync to team-context repo (sync backgrounded)
+$WAYFIND journal split 2>/dev/null
 $WAYFIND journal sync 2>/dev/null &