@equilateral_ai/mindmeld 3.0.0

package/src/collaboration/CollaborationPrompt.js

@@ -0,0 +1,460 @@
+/**
+ * Collaboration Prompt UX
+ *
+ * Prompts user when new project detected:
+ * - Collaborate with others vs Keep private
+ * - Discover collaborators from git/CODEOWNERS
+ * - Setup project-scoped memory
+ *
+ * Part of Rapport v3 project detection flow.
+ */
+
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const fs = require('fs').promises;
+const path = require('path');
+
+const execAsync = promisify(exec);
+
+class CollaborationPrompt {
+  constructor(config = {}) {
+    this.config = {
+      minCommitsToInclude: config.minCommitsToInclude || 3,
+      maxCollaborators: config.maxCollaborators || 10,
+      ...config
+    };
+  }
+
+  /**
+   * Prompt user for collaboration preferences
+   *
+   * Returns: { collaborate, collaborators, private }
+   */
+  async prompt(projectPath, projectName) {
+    console.log('\n┌─────────────────────────────────────────┐');
+    console.log(`│ New project detected: ${projectName.padEnd(18)} │`);
+    console.log('│                                         │');
+    console.log('│ Would you like to:                      │');
+    console.log('│ 1. Collaborate with others              │');
+    console.log('│ 2. Keep private (solo)                  │');
+    console.log('└─────────────────────────────────────────┘\n');
+
+    const choice = await this.getUserChoice(['1', '2']);
+
+    if (choice === '2') {
+      // Private project
+      return {
+        collaborate: false,
+        collaborators: [],
+        private: true
+      };
+    }
+
+    // Discover collaborators
+    const discovered = await this.discoverCollaborators(projectPath);
+
+    if (discovered.length === 0) {
+      console.log('\nNo collaborators detected from git history.');
+      console.log('Starting as solo project (you can add collaborators later).\n');
+
+      return {
+        collaborate: false,
+        collaborators: [],
+        private: false
+      };
+    }
+
+    // Show discovered collaborators
+    console.log('\n┌─────────────────────────────────────────┐');
+    console.log(`│ Who's working on ${projectName.padEnd(20)} │`);
+    console.log('│                                         │');
+    console.log('│ Detected from git history:              │');
+
+    for (const collab of discovered) {
+      const line = `│ ✓ ${collab.name.padEnd(25)} (${collab.commits} commits)`;
+      console.log(line.padEnd(42) + '│');
+    }
+
+    console.log('│                                         │');
+    console.log('│ Include all? (y/n)                      │');
+    console.log('└─────────────────────────────────────────┘\n');
+
+    const includeAll = await this.getUserChoice(['y', 'n']);
+
+    let collaborators = discovered;
+
+    if (includeAll === 'n') {
+      // Let user select which ones to include
+      collaborators = await this.selectCollaborators(discovered);
+    }
+
+    // Ask if they want to add more
+    console.log('\nAdd more collaborators? (y/n)');
+    const addMore = await this.getUserChoice(['y', 'n']);
+
+    if (addMore === 'y') {
+      const additional = await this.promptForAdditional();
+      collaborators = [...collaborators, ...additional];
+    }
+
+    return {
+      collaborate: true,
+      collaborators,
+      private: false
+    };
+  }
+
+  /**
+   * Discover collaborators from git history
+   */
+  async discoverCollaborators(projectPath) {
+    const collaborators = [];
+
+    try {
+      // Get git contributors
+      const gitContributors = await this.getGitContributors(projectPath);
+      collaborators.push(...gitContributors);
+
+      // Get from CODEOWNERS
+      const codeowners = await this.parseCodeowners(projectPath);
+      collaborators.push(...codeowners);
+
+      // Get from package.json
+      const pkgContributors = await this.getPackageContributors(projectPath);
+      collaborators.push(...pkgContributors);
+
+      // Deduplicate by email
+      return this.deduplicateCollaborators(collaborators);
+
+    } catch (error) {
+      console.error('Error discovering collaborators:', error.message);
+      return [];
+    }
+  }
+
+  /**
+   * Get contributors from git history
+   */
+  async getGitContributors(projectPath) {
+    try {
+      const { stdout } = await execAsync(
+        'git log --format="%an|%ae" | sort | uniq -c | sort -rn',
+        { cwd: projectPath }
+      );
+
+      const contributors = [];
+      const lines = stdout.trim().split('\n');
+
+      for (const line of lines) {
+        const match = line.trim().match(/^\s*(\d+)\s+(.+)\|(.+)$/);
+        if (match) {
+          const [, commits, name, email] = match;
+          const commitCount = parseInt(commits);
+
+          if (commitCount >= this.config.minCommitsToInclude) {
+            contributors.push({
+              name: name.trim(),
+              email: email.trim(),
+              commits: commitCount,
+              source: 'git'
+            });
+          }
+        }
+      }
+
+      return contributors;
+
+    } catch (error) {
+      // Not a git repo or git not available
+      return [];
+    }
+  }
+
+  /**
+   * Parse CODEOWNERS file
+   */
+  async parseCodeowners(projectPath) {
+    const codeownersPath = path.join(projectPath, 'CODEOWNERS');
+
+    try {
+      const content = await fs.readFile(codeownersPath, 'utf-8');
+      const collaborators = [];
+
+      const lines = content.split('\n');
+      for (const line of lines) {
+        // Skip comments and empty lines
+        if (line.trim().startsWith('#') || !line.trim()) {
+          continue;
+        }
+
+        // Extract GitHub handles or emails
+        const handles = line.match(/@[\w-]+/g);
+        if (handles) {
+          for (const handle of handles) {
+            collaborators.push({
+              name: handle.substring(1),  // Remove @
+              email: `${handle.substring(1)}@github.com`,
+              source: 'CODEOWNERS'
+            });
+          }
+        }
+
+        const emails = line.match(/[\w.-]+@[\w.-]+/g);
+        if (emails) {
+          for (const email of emails) {
+            collaborators.push({
+              name: email.split('@')[0],
+              email,
+              source: 'CODEOWNERS'
+            });
+          }
+        }
+      }
+
+      return collaborators;
+
+    } catch (error) {
+      // No CODEOWNERS file
+      return [];
+    }
+  }
+
+  /**
+   * Get contributors from package.json
+   */
+  async getPackageContributors(projectPath) {
+    const packagePath = path.join(projectPath, 'package.json');
+
+    try {
+      const content = await fs.readFile(packagePath, 'utf-8');
+      const pkg = JSON.parse(content);
+      const collaborators = [];
+
+      // Author
+      if (pkg.author) {
+        const author = typeof pkg.author === 'string'
+          ? this.parseContributor(pkg.author)
+          : pkg.author;
+
+        if (author) {
+          collaborators.push({
+            ...author,
+            source: 'package.json'
+          });
+        }
+      }
+
+      // Contributors
+      if (Array.isArray(pkg.contributors)) {
+        for (const contrib of pkg.contributors) {
+          const parsed = typeof contrib === 'string'
+            ? this.parseContributor(contrib)
+            : contrib;
+
+          if (parsed) {
+            collaborators.push({
+              ...parsed,
+              source: 'package.json'
+            });
+          }
+        }
+      }
+
+      return collaborators;
+
+    } catch (error) {
+      // No package.json or parse error
+      return [];
+    }
+  }
+
+  /**
+   * Parse contributor string
+   * Examples: "John Doe <john@example.com>", "john@example.com"
+   */
+  parseContributor(str) {
+    const match = str.match(/^([^<]+?)\s*<([^>]+)>$/);
+
+    if (match) {
+      return {
+        name: match[1].trim(),
+        email: match[2].trim()
+      };
+    }
+
+    // Just email
+    if (str.includes('@')) {
+      return {
+        name: str.split('@')[0],
+        email: str.trim()
+      };
+    }
+
+    return null;
+  }
+
+  /**
+   * Deduplicate collaborators by email
+   */
+  deduplicateCollaborators(collaborators) {
+    const seen = new Map();
+
+    for (const collab of collaborators) {
+      if (!collab.email) continue;
+
+      const email = collab.email.toLowerCase();
+
+      if (!seen.has(email)) {
+        seen.set(email, collab);
+      } else {
+        // Merge commit counts if available
+        const existing = seen.get(email);
+        if (collab.commits) {
+          existing.commits = (existing.commits || 0) + collab.commits;
+        }
+      }
+    }
+
+    return Array.from(seen.values())
+      .sort((a, b) => (b.commits || 0) - (a.commits || 0))
+      .slice(0, this.config.maxCollaborators);
+  }
+
+  /**
+   * Let user select specific collaborators
+   */
+  async selectCollaborators(discovered) {
+    const selected = [];
+
+    console.log('\nSelect collaborators to include:\n');
+
+    for (let i = 0; i < discovered.length; i++) {
+      const collab = discovered[i];
+      console.log(`${i + 1}. ${collab.name} (${collab.email})`);
+    }
+
+    console.log('\nEnter numbers separated by commas (e.g., 1,2,3):');
+
+    const input = await this.getUserInput();
+    const indices = input.split(',').map(s => parseInt(s.trim()) - 1);
+
+    for (const index of indices) {
+      if (index >= 0 && index < discovered.length) {
+        selected.push(discovered[index]);
+      }
+    }
+
+    return selected;
+  }
+
+  /**
+   * Prompt for additional collaborators
+   */
+  async promptForAdditional() {
+    const additional = [];
+
+    console.log('\nEnter collaborator details:');
+
+    while (true) {
+      console.log('\nName:');
+      const name = await this.getUserInput();
+
+      console.log('Email:');
+      const email = await this.getUserInput();
+
+      if (name && email) {
+        additional.push({
+          name: name.trim(),
+          email: email.trim(),
+          source: 'manual'
+        });
+      }
+
+      console.log('\nAdd another? (y/n)');
+      const addAnother = await this.getUserChoice(['y', 'n']);
+
+      if (addAnother === 'n') {
+        break;
+      }
+    }
+
+    return additional;
+  }
+
+  /**
+   * Get user choice (single character)
+   */
+  async getUserChoice(validChoices) {
+    return new Promise((resolve) => {
+      process.stdin.once('data', (data) => {
+        const choice = data.toString().trim().toLowerCase();
+
+        if (validChoices.includes(choice)) {
+          resolve(choice);
+        } else {
+          console.log(`Invalid choice. Please enter one of: ${validChoices.join(', ')}`);
+          this.getUserChoice(validChoices).then(resolve);
+        }
+      });
+    });
+  }
+
+  /**
+   * Get user input (full line)
+   */
+  async getUserInput() {
+    return new Promise((resolve) => {
+      process.stdin.once('data', (data) => {
+        resolve(data.toString().trim());
+      });
+    });
+  }
+
+  /**
+   * Format collaborators for display
+   */
+  formatCollaborators(collaborators) {
+    return collaborators.map(c => ({
+      userId: this.generateUserId(c.email),
+      name: c.name,
+      email: c.email,
+      role: 'collaborator',
+      source: c.source,
+      commits: c.commits
+    }));
+  }
+
+  /**
+   * Generate user ID from email
+   */
+  generateUserId(email) {
+    // Simple: use email prefix
+    return email.split('@')[0].toLowerCase().replace(/[^a-z0-9]/g, '');
+  }
+
+  /**
+   * Create project configuration
+   */
+  createProjectConfig(projectName, collaborators, options = {}) {
+    return {
+      projectId: this.generateProjectId(projectName),
+      projectName,
+      created: new Date().toISOString(),
+      collaborators: this.formatCollaborators(collaborators),
+      private: options.private || false,
+      externalUsersAllowed: options.externalUsersAllowed || false
+    };
+  }
+
+  /**
+   * Generate project ID from name
+   */
+  generateProjectId(projectName) {
+    return projectName
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-|-$/g, '');
+  }
+}
+
+module.exports = CollaborationPrompt;