slashvibe-mcp 0.3.19 → 0.3.21

package/tools/lib/git-bundle.js

@@ -0,0 +1,407 @@
+/**
+ * Git Bundle Library
+ *
+ * Creates and validates git bundles for session sharing.
+ * Used by broadcast.js to capture code changes during a broadcast.
+ *
+ * Key functions:
+ * - captureSessionStart() - Returns current HEAD commit
+ * - createBundle(startCommit) - Creates bundle from startCommit to HEAD
+ * - validateBundle(buffer) - Validates bundle integrity
+ */
+
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Max bundle size (10MB)
+const MAX_BUNDLE_SIZE = 10 * 1024 * 1024;
+
+// Files to exclude from bundles (security)
+const EXCLUDED_PATTERNS = [
+  '.env',
+  '.env.*',
+  '*.pem',
+  '*.key',
+  '*.p12',
+  '*.pfx',
+  '.npmrc',
+  '.netrc',
+  'credentials.json',
+  'secrets.json',
+  '*_rsa',
+  '*_dsa',
+  '*_ed25519',
+  '*_ecdsa',
+  'id_rsa*',
+  'id_dsa*',
+  '*.keystore',
+];
+
+/**
+ * Check if we're in a git repository
+ */
+function isGitRepo() {
+  try {
+    execSync('git rev-parse --is-inside-work-tree', {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Get current git branch
+ */
+function getCurrentBranch() {
+  try {
+    return execSync('git rev-parse --abbrev-ref HEAD', {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    }).trim();
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Get current HEAD commit hash
+ */
+function getHeadCommit() {
+  try {
+    return execSync('git rev-parse HEAD', {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    }).trim();
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Get commit count between two commits
+ */
+function getCommitCount(startCommit, endCommit = 'HEAD') {
+  try {
+    const output = execSync(`git rev-list --count ${startCommit}..${endCommit}`, {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+    return parseInt(output.trim(), 10);
+  } catch (e) {
+    return 0;
+  }
+}
+
+/**
+ * Get list of files changed between commits
+ */
+function getChangedFiles(startCommit, endCommit = 'HEAD') {
+  try {
+    const output = execSync(`git diff --name-only ${startCommit}..${endCommit}`, {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+    return output.trim().split('\n').filter(Boolean);
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Check if any excluded files would be in the bundle
+ */
+function hasExcludedFiles(changedFiles) {
+  const excluded = [];
+
+  for (const file of changedFiles) {
+    const basename = path.basename(file);
+
+    for (const pattern of EXCLUDED_PATTERNS) {
+      // Simple glob matching
+      if (pattern.startsWith('*')) {
+        const suffix = pattern.slice(1);
+        if (basename.endsWith(suffix)) {
+          excluded.push(file);
+          break;
+        }
+      } else if (pattern.endsWith('*')) {
+        const prefix = pattern.slice(0, -1);
+        if (basename.startsWith(prefix)) {
+          excluded.push(file);
+          break;
+        }
+      } else if (pattern.includes('*')) {
+        // Pattern like ".env.*"
+        const [prefix, suffix] = pattern.split('*');
+        if (basename.startsWith(prefix) && (suffix === '' || basename.endsWith(suffix))) {
+          excluded.push(file);
+          break;
+        }
+      } else if (basename === pattern || file === pattern) {
+        excluded.push(file);
+        break;
+      }
+    }
+  }
+
+  return excluded;
+}
+
+/**
+ * Capture git state at session start
+ * @returns {object} - { success, commit, branch, error? }
+ */
+function captureSessionStart() {
+  if (!isGitRepo()) {
+    return { success: false, error: 'Not a git repository' };
+  }
+
+  const commit = getHeadCommit();
+  const branch = getCurrentBranch();
+
+  if (!commit) {
+    return { success: false, error: 'Could not get HEAD commit' };
+  }
+
+  return {
+    success: true,
+    commit,
+    branch,
+    capturedAt: new Date().toISOString(),
+  };
+}
+
+/**
+ * Create a git bundle from startCommit to HEAD
+ * @param {string} startCommit - Starting commit hash
+ * @returns {object} - { success, buffer, metadata, error? }
+ */
+function createBundle(startCommit) {
+  if (!isGitRepo()) {
+    return { success: false, error: 'Not a git repository' };
+  }
+
+  if (!startCommit) {
+    return { success: false, error: 'Start commit required' };
+  }
+
+  const endCommit = getHeadCommit();
+  const branch = getCurrentBranch();
+
+  if (!endCommit) {
+    return { success: false, error: 'Could not get HEAD commit' };
+  }
+
+  // Check if there are any new commits
+  const commitCount = getCommitCount(startCommit, endCommit);
+  if (commitCount === 0) {
+    return {
+      success: false,
+      error: 'No new commits since session start',
+      metadata: {
+        startCommit,
+        endCommit,
+        branch,
+      },
+    };
+  }
+
+  // Check for excluded files
+  const changedFiles = getChangedFiles(startCommit, endCommit);
+  const excludedFiles = hasExcludedFiles(changedFiles);
+
+  if (excludedFiles.length > 0) {
+    console.log(`[git-bundle] Warning: Excluding sensitive files: ${excludedFiles.join(', ')}`);
+  }
+
+  // Create temp file for bundle
+  const tmpDir = os.tmpdir();
+  const bundlePath = path.join(tmpDir, `vibe-bundle-${Date.now()}.bundle`);
+
+  try {
+    // Create the bundle
+    // Format: git bundle create <file> <range>
+    const bundleRange = `${startCommit}..HEAD`;
+
+    execSync(`git bundle create "${bundlePath}" ${bundleRange}`, {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+
+    // Read the bundle
+    const buffer = fs.readFileSync(bundlePath);
+
+    // Check size
+    if (buffer.length > MAX_BUNDLE_SIZE) {
+      fs.unlinkSync(bundlePath);
+      return {
+        success: false,
+        error: `Bundle too large (${Math.round(buffer.length / 1024 / 1024)}MB > ${MAX_BUNDLE_SIZE / 1024 / 1024}MB limit)`,
+      };
+    }
+
+    // Clean up temp file
+    fs.unlinkSync(bundlePath);
+
+    const metadata = {
+      initialCommit: startCommit,
+      finalCommit: endCommit,
+      branch,
+      commitCount,
+      changedFiles: changedFiles.filter((f) => !excludedFiles.includes(f)),
+      excludedFiles,
+      size: buffer.length,
+      createdAt: new Date().toISOString(),
+    };
+
+    console.log(`[git-bundle] Created bundle: ${commitCount} commits, ${changedFiles.length} files, ${buffer.length} bytes`);
+
+    return {
+      success: true,
+      buffer,
+      metadata,
+    };
+  } catch (error) {
+    // Clean up on error
+    try {
+      if (fs.existsSync(bundlePath)) {
+        fs.unlinkSync(bundlePath);
+      }
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+
+    console.error('[git-bundle] Failed to create bundle:', error.message);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Validate a git bundle
+ * @param {Buffer} buffer - The bundle data
+ * @returns {object} - { success, info, error? }
+ */
+function validateBundle(buffer) {
+  if (!buffer || buffer.length === 0) {
+    return { success: false, error: 'Empty buffer' };
+  }
+
+  // Check magic bytes (git bundles start with "# v2 git bundle" or "# v3 git bundle")
+  const header = buffer.slice(0, 20).toString('utf8');
+  if (!header.startsWith('# v2 git bundle') && !header.startsWith('# v3 git bundle')) {
+    return { success: false, error: 'Invalid bundle format' };
+  }
+
+  // Write to temp and verify
+  const tmpDir = os.tmpdir();
+  const bundlePath = path.join(tmpDir, `vibe-verify-${Date.now()}.bundle`);
+
+  try {
+    fs.writeFileSync(bundlePath, buffer);
+
+    // Verify the bundle
+    const output = execSync(`git bundle verify "${bundlePath}"`, {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+
+    fs.unlinkSync(bundlePath);
+
+    return {
+      success: true,
+      info: output.trim(),
+      size: buffer.length,
+    };
+  } catch (error) {
+    try {
+      if (fs.existsSync(bundlePath)) {
+        fs.unlinkSync(bundlePath);
+      }
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Apply a bundle to create a new branch (for forking)
+ * @param {Buffer} buffer - The bundle data
+ * @param {string} branchName - Name for the new branch
+ * @returns {object} - { success, branch, error? }
+ */
+function applyBundle(buffer, branchName = 'forked-session') {
+  if (!isGitRepo()) {
+    return { success: false, error: 'Not a git repository' };
+  }
+
+  const validation = validateBundle(buffer);
+  if (!validation.success) {
+    return { success: false, error: `Invalid bundle: ${validation.error}` };
+  }
+
+  const tmpDir = os.tmpdir();
+  const bundlePath = path.join(tmpDir, `vibe-apply-${Date.now()}.bundle`);
+
+  try {
+    fs.writeFileSync(bundlePath, buffer);
+
+    // Get the refs in the bundle
+    const listOutput = execSync(`git bundle list-heads "${bundlePath}"`, {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+
+    const refs = listOutput.trim().split('\n');
+    if (refs.length === 0) {
+      throw new Error('No refs in bundle');
+    }
+
+    // Get the first commit hash from the bundle
+    const firstRef = refs[0].split(/\s+/)[0];
+
+    // Unbundle (fetch from bundle)
+    execSync(`git fetch "${bundlePath}" ${firstRef}:${branchName}`, {
+      stdio: 'pipe',
+    });
+
+    fs.unlinkSync(bundlePath);
+
+    console.log(`[git-bundle] Applied bundle to branch: ${branchName}`);
+
+    return {
+      success: true,
+      branch: branchName,
+      refs: refs.map((r) => r.split(/\s+/)),
+    };
+  } catch (error) {
+    try {
+      if (fs.existsSync(bundlePath)) {
+        fs.unlinkSync(bundlePath);
+      }
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+
+    console.error('[git-bundle] Failed to apply bundle:', error.message);
+    return { success: false, error: error.message };
+  }
+}
+
+module.exports = {
+  isGitRepo,
+  getCurrentBranch,
+  getHeadCommit,
+  captureSessionStart,
+  createBundle,
+  validateBundle,
+  applyBundle,
+  MAX_BUNDLE_SIZE,
+  EXCLUDED_PATTERNS,
+};

package/tools/session.js

@@ -8,11 +8,13 @@
  * - session save --room X     → Save specific broadcast
  * - session list              → List my sessions
  * - session browse            → Browse all public sessions
- * - session fork <id>         → Fork a session
+ * - session fork <id>         → Fork a session (story only)
+ * - session fork <id> --full  → Fork with git bundle (get actual code)
  * - session view <id>         → View session details
  */
 
 const config = require('../config');
+const gitApply = require('./lib/git-apply');
 
 const definition = {
   name: 'vibe_session',
@@ -45,6 +47,14 @@ const definition = {
       limit: {
         type: 'number',
         description: 'Number of sessions to show (default: 10)'
+      },
+      full: {
+        type: 'boolean',
+        description: 'For fork: download git bundle and apply locally (default: false)'
+      },
+      branch: {
+        type: 'string',
+        description: 'For fork --full: branch name for applied code (default: forked-session)'
       }
     }
   }
@@ -373,6 +383,9 @@ async function handler(args) {
     }
 
     const sessionId = args.id;
+    const fullFork = args.full === true;
+    const branchName = args.branch || 'forked-session';
+    const forkLevel = fullFork ? 'full' : 'story_only';
 
     try {
       const response = await fetch(`${apiUrl}/api/sessions/fork`, {
@@ -382,7 +395,7 @@ async function handler(args) {
           parentSessionId: sessionId,
           forkerHandle: myHandle,
           forkTo: 'session',
-          forkLevel: 'story_only'
+          forkLevel
         })
       });
 
@@ -404,8 +417,42 @@ async function handler(args) {
       display += `**From:** ${data.parentSession?.title || sessionId}\n`;
       display += `**By:** @${data.parentSession?.author || 'unknown'}\n\n`;
       display += `**Fork ID:** ${data.forkId}\n\n`;
+
+      // Handle full fork with git bundle
+      if (fullFork && data.git?.bundleDownloadUrl) {
+        display += `📦 **Downloading git bundle...**\n`;
+
+        const applyResult = await gitApply.applyBundleFromUrl(
+          data.git.bundleDownloadUrl,
+          branchName
+        );
+
+        if (applyResult.success) {
+          display += `✅ **Code applied to branch:** \`${applyResult.branch}\`\n\n`;
+          display += `**Git info:**\n`;
+          display += `- Branch: ${data.git.branch || 'unknown'}\n`;
+          display += `- Commits: ${data.git.initialCommit?.slice(0, 7)}..${data.git.finalCommit?.slice(0, 7)}\n`;
+          display += `- Bundle size: ${Math.round(applyResult.size / 1024)}KB\n\n`;
+          display += `**Next steps:**\n`;
+          display += `\`\`\`\ngit checkout ${applyResult.branch}\n\`\`\`\n`;
+        } else {
+          display += `⚠️ **Bundle apply failed:** ${applyResult.error}\n\n`;
+          display += `_The session was forked, but the code bundle could not be applied._\n`;
+          display += `_You can still view the story at the URL below._\n\n`;
+        }
+      } else if (fullFork && data.git?.hasBundleAvailable && !data.git?.bundleDownloadUrl) {
+        display += `⚠️ **Git bundle not available** (R2 storage may not be configured)\n\n`;
+      } else if (fullFork && !data.git?.hasBundleAvailable) {
+        display += `ℹ️ **No git bundle** for this session (no commits during broadcast)\n\n`;
+      }
+
       display += `**View the story:**\n${data.storyUrl}\n\n`;
-      display += `_Learn from this session and build your own version!_`;
+
+      if (!fullFork && data.git?.hasBundleAvailable) {
+        display += `_💡 Want the actual code? Use \`vibe session fork ${sessionId} --full\`_`;
+      } else if (!fullFork) {
+        display += `_Learn from this session and build your own version!_`;
+      }
 
       return { display };
 

package/tools/streak.js

@@ -0,0 +1,147 @@
+/**
+ * vibe_streak — View and track your building streak
+ *
+ * Streaks drive retention through daily habit formation.
+ *
+ * Badge Tiers:
+ * - 7 days: Verified Builder
+ * - 14 days: Consistent Builder
+ * - 30 days: Dedicated Builder
+ * - 60 days: Relentless Builder
+ * - 100 days: Legendary Builder
+ *
+ * Streak Freezes:
+ * - Earn 1 freeze every 7 days (max 3)
+ * - Auto-used if you miss a day
+ */
+
+const config = require('../config');
+
+const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+
+const definition = {
+  name: 'vibe_streak',
+  description: 'View your building streak, badges, and freezes',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      user: {
+        type: 'string',
+        description: 'Username to check (default: yourself)'
+      }
+    }
+  }
+};
+
+function requireInit() {
+  if (!config.isInitialized()) {
+    throw new Error('Not initialized. Run `vibe init` first.');
+  }
+}
+
+async function handler(args) {
+  requireInit();
+
+  const myHandle = config.getHandle();
+  const targetUser = args.user ? args.user.toLowerCase().replace('@', '') : myHandle;
+  const isOwnStreak = targetUser === myHandle.toLowerCase();
+
+  try {
+    const endpoint = `${API_URL}/api/growth/streak?user=${targetUser}`;
+    const response = await fetch(endpoint);
+    const data = await response.json();
+
+    if (!data.success) {
+      return { display: `\u274c Failed to load streak: ${data.error}` };
+    }
+
+    const streak = data.streak;
+    let display = '';
+
+    // Header with current streak
+    if (isOwnStreak) {
+      display += `## Your Building Streak\n\n`;
+    } else {
+      display += `## @${targetUser}'s Building Streak\n\n`;
+    }
+
+    // Big streak number with fire emoji based on length
+    const fireEmoji = streak.current >= 30 ? '\ud83d\udd25\ud83d\udd25\ud83d\udd25' :
+                      streak.current >= 14 ? '\ud83d\udd25\ud83d\udd25' :
+                      streak.current >= 7 ? '\ud83d\udd25' : '\ud83d\udcaa';
+
+    display += `### ${fireEmoji} ${streak.current} Day Streak\n\n`;
+
+    // Status indicators
+    if (streak.atRisk) {
+      display += `\u26a0\ufe0f **AT RISK** - Ship something today to keep your streak!\n\n`;
+    } else if (streak.isActiveToday) {
+      display += `\u2705 **Active today** - streak is safe!\n\n`;
+    }
+
+    // Stats
+    display += `| Stat | Value |\n`;
+    display += `|------|-------|\n`;
+    display += `| Current Streak | ${streak.current} days |\n`;
+    display += `| Longest Streak | ${streak.longest} days |\n`;
+    display += `| Freezes Available | ${data.freezesAvailable}\u2744\ufe0f |\n`;
+    display += `| Freezes Used | ${streak.freezesUsed || 0} |\n\n`;
+
+    // Current tier
+    if (streak.tier?.current) {
+      display += `### Current Tier: ${streak.tier.current.emoji} ${streak.tier.current.label}\n\n`;
+    }
+
+    // Next badge progress
+    if (data.nextBadge) {
+      const progress = Math.round((streak.current / data.nextBadge.daysAway + streak.current) * 100);
+      display += `### Next Badge: ${data.nextBadge.emoji} ${data.nextBadge.label}\n`;
+      display += `**${data.nextBadge.daysAway} days** to unlock\n\n`;
+    } else if (streak.current >= 100) {
+      display += `### \ud83c\udf1f All badges unlocked! You're a legend.\n\n`;
+    }
+
+    // Earned badges
+    if (streak.badges && streak.badges.length > 0) {
+      display += `### Earned Badges\n`;
+      const badgeInfo = {
+        verified_builder: { emoji: '\u2705', label: 'Verified Builder (7d)' },
+        consistent_builder: { emoji: '\ud83d\udcaa', label: 'Consistent Builder (14d)' },
+        dedicated_builder: { emoji: '\ud83d\udd25', label: 'Dedicated Builder (30d)' },
+        relentless_builder: { emoji: '\u26a1', label: 'Relentless Builder (60d)' },
+        legendary_builder: { emoji: '\ud83d\udc51', label: 'Legendary Builder (100d)' }
+      };
+
+      for (const badge of streak.badges) {
+        const info = badgeInfo[badge] || { emoji: '\ud83c\udfc5', label: badge };
+        display += `- ${info.emoji} ${info.label}\n`;
+      }
+      display += '\n';
+    }
+
+    // 30-day calendar visualization
+    if (data.calendar) {
+      display += `### Last 30 Days\n`;
+      display += '`';
+      for (const day of data.calendar) {
+        display += day.active ? '\u25a0' : '\u25a1';
+      }
+      display += '`\n';
+      display += '_(\u25a0 = active day)_\n';
+    }
+
+    // Tip for maintaining streak
+    if (isOwnStreak && !streak.isActiveToday) {
+      display += `\n---\n**Tip:** Ship something or post to the board to record today's activity!`;
+    }
+
+    return { display };
+
+  } catch (e) {
+    return {
+      display: `## Building Streak\n\n\u274c **Failed to load**\n\nError: ${e.message}`
+    };
+  }
+}
+
+module.exports = { definition, handler };