@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/commands/team/index.js

@@ -0,0 +1,309 @@
+/**
+ * Team Commands
+ * Team collaboration CLI commands
+ */
+import { ui } from '../../wizard/ui';
+import { teamClient } from '../../clients/enterprise-client';
+import { getAuthStore } from '../../auth';
+/**
+ * Get current user ID from auth store
+ */
+function getCurrentUserId() {
+    const authStore = getAuthStore();
+    const auth = authStore.load();
+    const userId = auth?.identity?.github?.username;
+    if (!userId) {
+        throw new Error('Not authenticated. Run `nimbus login` first.');
+    }
+    return userId;
+}
+/**
+ * Get current team ID from config or environment
+ */
+function getCurrentTeamId() {
+    return process.env.NIMBUS_TEAM_ID || null;
+}
+/**
+ * Parse team create options
+ */
+export function parseTeamCreateOptions(args) {
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--non-interactive') {
+            options.nonInteractive = true;
+        }
+        else if (!arg.startsWith('-') && !options.name) {
+            options.name = arg;
+        }
+    }
+    return options;
+}
+/**
+ * Parse team invite options
+ */
+export function parseTeamInviteOptions(args) {
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--role' && args[i + 1]) {
+            options.role = args[++i];
+        }
+        else if (arg === '--non-interactive') {
+            options.nonInteractive = true;
+        }
+        else if (!arg.startsWith('-') && !options.email) {
+            options.email = arg;
+        }
+    }
+    return options;
+}
+/**
+ * Parse team members options
+ */
+export function parseTeamMembersOptions(args) {
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--json') {
+            options.json = true;
+        }
+        else if (arg === '--non-interactive') {
+            options.nonInteractive = true;
+        }
+    }
+    return options;
+}
+/**
+ * Parse team remove options
+ */
+export function parseTeamRemoveOptions(args) {
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--force' || arg === '-f') {
+            options.force = true;
+        }
+        else if (arg === '--non-interactive') {
+            options.nonInteractive = true;
+        }
+        else if (!arg.startsWith('-') && !options.email) {
+            options.email = arg;
+        }
+    }
+    return options;
+}
+/**
+ * Parse team switch options
+ */
+export function parseTeamSwitchOptions(args) {
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--non-interactive') {
+            options.nonInteractive = true;
+        }
+        else if (!arg.startsWith('-') && !options.teamId) {
+            options.teamId = arg;
+        }
+    }
+    return options;
+}
+/**
+ * Team create command
+ */
+export async function teamCreateCommand(options) {
+    try {
+        const name = options.name;
+        if (!name) {
+            ui.error('Team name is required');
+            ui.info('Usage: nimbus team create <name>');
+            return;
+        }
+        const userId = getCurrentUserId();
+        ui.startSpinner({ message: 'Creating team...' });
+        const team = await teamClient.createTeam({ name, ownerId: userId });
+        ui.stopSpinnerSuccess(`Team "${team.name}" created`);
+        ui.newLine();
+        ui.info(`Team ID: ${team.id}`);
+        ui.info(`To use this team, run: nimbus team switch ${team.id}`);
+        ui.info(`Or set environment variable: export NIMBUS_TEAM_ID=${team.id}`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to create team');
+        ui.error(error.message);
+    }
+}
+/**
+ * Team invite command
+ */
+export async function teamInviteCommand(options) {
+    try {
+        const email = options.email;
+        if (!email) {
+            ui.error('Email is required');
+            ui.info('Usage: nimbus team invite <email> [--role member|admin|viewer]');
+            return;
+        }
+        const teamId = getCurrentTeamId();
+        if (!teamId) {
+            ui.error('No team selected. Run `nimbus team switch <team-id>` first.');
+            return;
+        }
+        ui.startSpinner({ message: `Inviting ${email}...` });
+        const member = await teamClient.inviteMember(teamId, {
+            email,
+            role: options.role || 'member',
+        });
+        ui.stopSpinnerSuccess(`Invited ${email} as ${member.role}`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to invite member');
+        ui.error(error.message);
+    }
+}
+/**
+ * Team members command
+ */
+export async function teamMembersCommand(options) {
+    try {
+        const teamId = getCurrentTeamId();
+        if (!teamId) {
+            ui.error('No team selected. Run `nimbus team switch <team-id>` first.');
+            return;
+        }
+        ui.startSpinner({ message: 'Fetching members...' });
+        const members = await teamClient.listMembers(teamId);
+        ui.stopSpinnerSuccess(`Found ${members.length} members`);
+        if (options.json) {
+            console.log(JSON.stringify(members, null, 2));
+            return;
+        }
+        ui.newLine();
+        ui.table({
+            columns: [
+                { key: 'email', header: 'Email' },
+                { key: 'role', header: 'Role' },
+                { key: 'joinedAt', header: 'Joined' },
+            ],
+            data: members.map(m => ({
+                email: m.user?.email || m.userId,
+                role: m.role,
+                joinedAt: new Date(m.joinedAt).toLocaleDateString(),
+            })),
+        });
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to list members');
+        ui.error(error.message);
+    }
+}
+/**
+ * Team remove command
+ */
+export async function teamRemoveCommand(options) {
+    try {
+        const email = options.email;
+        if (!email) {
+            ui.error('Email is required');
+            ui.info('Usage: nimbus team remove <email>');
+            return;
+        }
+        const teamId = getCurrentTeamId();
+        if (!teamId) {
+            ui.error('No team selected. Run `nimbus team switch <team-id>` first.');
+            return;
+        }
+        // First, find the user ID by email from members list
+        const members = await teamClient.listMembers(teamId);
+        const member = members.find(m => m.user?.email === email);
+        if (!member) {
+            ui.error(`Member with email ${email} not found`);
+            return;
+        }
+        ui.startSpinner({ message: `Removing ${email}...` });
+        await teamClient.removeMember(teamId, member.userId);
+        ui.stopSpinnerSuccess(`Removed ${email} from team`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to remove member');
+        ui.error(error.message);
+    }
+}
+/**
+ * Team switch command
+ */
+export async function teamSwitchCommand(options) {
+    try {
+        const userId = getCurrentUserId();
+        // If no team ID provided, list teams for selection
+        if (!options.teamId) {
+            ui.startSpinner({ message: 'Fetching teams...' });
+            const teams = await teamClient.listTeams(userId);
+            ui.stopSpinnerSuccess(`Found ${teams.length} teams`);
+            if (teams.length === 0) {
+                ui.info('No teams found. Create one with `nimbus team create <name>`');
+                return;
+            }
+            ui.newLine();
+            ui.info('Available teams:');
+            for (const team of teams) {
+                ui.print(`  ${team.id} - ${team.name} (${team.plan})`);
+            }
+            ui.newLine();
+            ui.info('To switch: nimbus team switch <team-id>');
+            ui.info('Or set: export NIMBUS_TEAM_ID=<team-id>');
+            return;
+        }
+        // Verify team exists and user has access
+        ui.startSpinner({ message: 'Switching team...' });
+        const team = await teamClient.getTeam(options.teamId);
+        if (!team) {
+            ui.stopSpinnerFail('Team not found');
+            return;
+        }
+        ui.stopSpinnerSuccess(`Switched to team "${team.name}"`);
+        ui.newLine();
+        ui.info(`Set this environment variable to persist:`);
+        ui.print(`  export NIMBUS_TEAM_ID=${team.id}`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to switch team');
+        ui.error(error.message);
+    }
+}
+/**
+ * Main team command dispatcher
+ */
+export async function teamCommand(subcommand, args) {
+    switch (subcommand) {
+        case 'create':
+            await teamCreateCommand(parseTeamCreateOptions(args));
+            break;
+        case 'invite':
+            await teamInviteCommand(parseTeamInviteOptions(args));
+            break;
+        case 'members':
+            await teamMembersCommand(parseTeamMembersOptions(args));
+            break;
+        case 'remove':
+            await teamRemoveCommand(parseTeamRemoveOptions(args));
+            break;
+        case 'switch':
+            await teamSwitchCommand(parseTeamSwitchOptions(args));
+            break;
+        case 'list':
+            await teamSwitchCommand(parseTeamSwitchOptions([])); // List mode
+            break;
+        default:
+            ui.error(`Unknown team command: ${subcommand}`);
+            ui.newLine();
+            ui.info('Available team commands:');
+            ui.print('  nimbus team create <name>     - Create a new team');
+            ui.print('  nimbus team invite <email>    - Invite a member');
+            ui.print('  nimbus team members           - List team members');
+            ui.print('  nimbus team remove <email>    - Remove a member');
+            ui.print('  nimbus team switch [team-id]  - Switch to a team');
+            ui.print('  nimbus team list              - List your teams');
+    }
+}

package/dist/src/commands/team-context.js

@@ -0,0 +1,200 @@
+/**
+ * Team NIMBUS.md Distribution (L6)
+ *
+ * Share project context files with team members.
+ *
+ *   nimbus team-context push     — share current NIMBUS.md via sharing service
+ *   nimbus team-context pull <url> — download NIMBUS.md, show diff, prompt before overwrite
+ *
+ * Also supports NIMBUS_INSTRUCTIONS_URL env var: on startup, fetch that URL
+ * and use as NIMBUS.md if local file not present.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ui } from '../wizard/ui';
+const NIMBUS_MD_PATHS = [
+    path.join(process.cwd(), 'NIMBUS.md'),
+    path.join(process.cwd(), '.nimbus', 'NIMBUS.md'),
+];
+function findLocalNimbusMd() {
+    for (const p of NIMBUS_MD_PATHS) {
+        if (fs.existsSync(p))
+            return p;
+    }
+    return null;
+}
+function computeDiff(oldContent, newContent) {
+    const oldLines = oldContent.split('\n');
+    const newLines = newContent.split('\n');
+    const lines = [];
+    const maxLen = Math.max(oldLines.length, newLines.length);
+    for (let i = 0; i < maxLen; i++) {
+        const old = oldLines[i];
+        const newLine = newLines[i];
+        if (old === undefined) {
+            lines.push(`+ ${newLine}`);
+        }
+        else if (newLine === undefined) {
+            lines.push(`- ${old}`);
+        }
+        else if (old !== newLine) {
+            lines.push(`- ${old}`);
+            lines.push(`+ ${newLine}`);
+        }
+    }
+    return lines.join('\n');
+}
+/** Path to the team.md file in the current project's .nimbus/ directory */
+const TEAM_MD_PATH = path.join(process.cwd(), '.nimbus', 'team.md');
+/** Regex to strip lines containing sensitive info */
+const SENSITIVE_PATTERN = /SENSITIVE:/i;
+/** Strip lines containing "SENSITIVE:" from NIMBUS.md before sharing */
+function stripSensitiveLines(content) {
+    return content
+        .split('\n')
+        .filter(line => !SENSITIVE_PATTERN.test(line))
+        .join('\n');
+}
+/**
+ * Merge non-duplicate sections from teamContent into localContent.
+ * Sections are identified by Markdown headings (## ...).
+ */
+function mergeSections(localContent, teamContent) {
+    // Split into sections by heading
+    const sectionRegex = /(?=^#{1,3} .+$)/m;
+    const localSections = localContent.split(sectionRegex);
+    const teamSections = teamContent.split(sectionRegex);
+    const localHeadings = new Set(localSections
+        .map(s => s.match(/^(#{1,3} .+)$/m)?.[1]?.trim())
+        .filter(Boolean));
+    const newSections = teamSections.filter(s => {
+        const heading = s.match(/^(#{1,3} .+)$/m)?.[1]?.trim();
+        return heading && !localHeadings.has(heading);
+    });
+    if (newSections.length === 0)
+        return localContent;
+    const merged = localContent.trimEnd() + '\n\n' + newSections.join('\n').trimStart();
+    return merged;
+}
+export async function teamContextCommand(subcommand, args) {
+    switch (subcommand) {
+        case 'push': {
+            // Git-based push: read NIMBUS.md, strip SENSITIVE lines, write to .nimbus/team.md
+            const localPath = findLocalNimbusMd();
+            if (!localPath) {
+                ui.warning('No NIMBUS.md found in current directory. Run `nimbus init` first.');
+                return;
+            }
+            const content = fs.readFileSync(localPath, 'utf-8');
+            const sanitized = stripSensitiveLines(content);
+            // Ensure .nimbus/ directory exists
+            const nimbusDir = path.dirname(TEAM_MD_PATH);
+            if (!fs.existsSync(nimbusDir)) {
+                fs.mkdirSync(nimbusDir, { recursive: true });
+            }
+            fs.writeFileSync(TEAM_MD_PATH, sanitized, 'utf-8');
+            ui.print(`${ui.color('✓', 'green')} Written sanitized context to ${TEAM_MD_PATH}`);
+            ui.dim(`Removed all lines containing "SENSITIVE:"`);
+            ui.newLine();
+            // Stage the file with git
+            try {
+                const { execFileSync } = await import('node:child_process');
+                execFileSync('git', ['add', TEAM_MD_PATH], {
+                    encoding: 'utf-8',
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    timeout: 10_000,
+                });
+                ui.print(`${ui.color('✓', 'green')} Staged .nimbus/team.md with git`);
+                ui.print('  Next step: git commit -m "chore: update team context" && git push');
+            }
+            catch {
+                ui.dim('(git stage skipped — not a git repo or git not in PATH)');
+                ui.print('  Copy .nimbus/team.md to your repository and commit/push it manually.');
+            }
+            ui.newLine();
+            ui.info('Note: Add .nimbus/team.md to version control (do NOT add .nimbus/team.md to .gitignore).');
+            ui.dim('Add NIMBUS.md to .gitignore if it contains sensitive local config.');
+            break;
+        }
+        case 'pull': {
+            // Git-based pull: read .nimbus/team.md from cwd, diff, merge
+            if (!fs.existsSync(TEAM_MD_PATH)) {
+                ui.error(`.nimbus/team.md not found in ${process.cwd()}`);
+                ui.dim('Run `git pull` to fetch the latest team context, then re-run this command.');
+                return;
+            }
+            const teamContent = fs.readFileSync(TEAM_MD_PATH, 'utf-8');
+            const targetPath = NIMBUS_MD_PATHS[0];
+            const existing = fs.existsSync(targetPath) ? fs.readFileSync(targetPath, 'utf-8') : null;
+            if (existing) {
+                const diff = computeDiff(existing, teamContent);
+                if (!diff) {
+                    ui.info('NIMBUS.md is already up to date with team.md.');
+                    return;
+                }
+                ui.header('NIMBUS.md vs .nimbus/team.md diff');
+                for (const line of diff.split('\n')) {
+                    if (line.startsWith('+')) {
+                        ui.print(ui.color(line, 'green'));
+                    }
+                    else if (line.startsWith('-')) {
+                        ui.print(ui.color(line, 'red'));
+                    }
+                    else {
+                        ui.print(line);
+                    }
+                }
+                ui.newLine();
+                // Prompt for confirmation
+                const { input: inputPrompt } = await import('../wizard/prompts');
+                const answer = await inputPrompt({
+                    message: 'Merge new sections from team.md into NIMBUS.md? [y/N]',
+                    defaultValue: 'N',
+                });
+                if (answer.toLowerCase() !== 'y') {
+                    ui.info('Aborted — NIMBUS.md not changed.');
+                    return;
+                }
+                // Merge: append non-duplicate sections
+                const merged = mergeSections(existing, teamContent);
+                fs.writeFileSync(targetPath, merged, 'utf-8');
+                ui.print(`${ui.color('✓', 'green')} Merged team context into ${targetPath}`);
+            }
+            else {
+                // No local NIMBUS.md — use team.md as starting point
+                fs.writeFileSync(targetPath, teamContent, 'utf-8');
+                ui.print(`${ui.color('✓', 'green')} Created ${targetPath} from .nimbus/team.md`);
+            }
+            ui.newLine();
+            ui.dim('Note: Add NIMBUS.md to .gitignore to keep local config private.');
+            ui.dim('Add .nimbus/team.md to version control to share project context with team.');
+            break;
+        }
+        default:
+            ui.print('Usage: nimbus team-context <push|pull>');
+            ui.print('');
+            ui.print('  push   Strip SENSITIVE: lines from NIMBUS.md, write to .nimbus/team.md, and git add');
+            ui.print('  pull   Read .nimbus/team.md, diff against NIMBUS.md, merge on confirmation');
+    }
+}
+/**
+ * Fetch NIMBUS.md from NIMBUS_INSTRUCTIONS_URL env var.
+ * Called on startup when no local NIMBUS.md exists.
+ */
+export async function fetchRemoteNimbusMd() {
+    const url = process.env.NIMBUS_INSTRUCTIONS_URL;
+    if (!url)
+        return null;
+    const localPath = findLocalNimbusMd();
+    if (localPath)
+        return null; // local file takes priority
+    try {
+        const response = await fetch(url, { signal: AbortSignal.timeout(10_000) });
+        if (!response.ok)
+            return null;
+        return await response.text();
+    }
+    catch {
+        return null;
+    }
+}