@build-astron-co/nimbus 0.2.0 → 0.4.0

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

@@ -0,0 +1,224 @@
+/**
+ * Billing Commands
+ * Billing and subscription CLI commands
+ */
+import { ui } from '../../wizard/ui';
+import { billingClient } from '../../clients/enterprise-client';
+/**
+ * Get current team ID from config or environment
+ */
+function getCurrentTeamId() {
+    return process.env.NIMBUS_TEAM_ID || null;
+}
+/**
+ * Parse billing status options
+ */
+export function parseBillingStatusOptions(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 billing upgrade options
+ */
+export function parseBillingUpgradeOptions(args) {
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--plan' && args[i + 1]) {
+            options.plan = args[++i];
+        }
+        else if (arg === '--non-interactive') {
+            options.nonInteractive = true;
+        }
+        else if (!arg.startsWith('-') && !options.plan) {
+            options.plan = arg;
+        }
+    }
+    return options;
+}
+/**
+ * Parse billing invoices options
+ */
+export function parseBillingInvoicesOptions(args) {
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--limit' && args[i + 1]) {
+            options.limit = parseInt(args[++i], 10);
+        }
+        else if (arg === '--json') {
+            options.json = true;
+        }
+        else if (arg === '--non-interactive') {
+            options.nonInteractive = true;
+        }
+    }
+    return options;
+}
+/**
+ * Billing status command
+ */
+export async function billingStatusCommand(options) {
+    try {
+        const teamId = getCurrentTeamId();
+        if (!teamId) {
+            ui.error('No team selected. Run `nimbus team switch <team-id>` first.');
+            return;
+        }
+        ui.startSpinner({ message: 'Fetching billing status...' });
+        const status = await billingClient.getStatus(teamId);
+        ui.stopSpinnerSuccess('Billing status retrieved');
+        if (options.json) {
+            console.log(JSON.stringify(status, null, 2));
+            return;
+        }
+        ui.newLine();
+        ui.header('Billing Status');
+        ui.print(`  Plan: ${status.plan.toUpperCase()}`);
+        ui.print(`  Status: ${status.status}`);
+        ui.print(`  Period: ${new Date(status.currentPeriodStart).toLocaleDateString()} - ${new Date(status.currentPeriodEnd).toLocaleDateString()}`);
+        ui.print(`  Seats: ${status.seats.used} / ${status.seats.total} used`);
+        if (status.cancelAtPeriodEnd) {
+            ui.warning('Subscription will cancel at end of period');
+        }
+        ui.newLine();
+        if (status.plan === 'free') {
+            ui.info('Upgrade to Pro for more seats and features:');
+            ui.print('  nimbus billing upgrade pro');
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to get billing status');
+        ui.error(error.message);
+    }
+}
+/**
+ * Billing upgrade command
+ */
+export async function billingUpgradeCommand(options) {
+    try {
+        const teamId = getCurrentTeamId();
+        if (!teamId) {
+            ui.error('No team selected. Run `nimbus team switch <team-id>` first.');
+            return;
+        }
+        const plan = options.plan;
+        if (!plan || !['pro', 'enterprise'].includes(plan)) {
+            ui.error('Plan is required');
+            ui.info('Usage: nimbus billing upgrade <pro|enterprise>');
+            return;
+        }
+        ui.startSpinner({ message: `Upgrading to ${plan}...` });
+        const status = await billingClient.subscribe(teamId, { plan });
+        ui.stopSpinnerSuccess(`Upgraded to ${plan.toUpperCase()}`);
+        ui.newLine();
+        ui.success(`Your team is now on the ${plan.toUpperCase()} plan!`);
+        ui.print(`  Seats available: ${status.seats.total}`);
+        ui.print(`  Next billing date: ${new Date(status.currentPeriodEnd).toLocaleDateString()}`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to upgrade');
+        ui.error(error.message);
+    }
+}
+/**
+ * Billing invoices command
+ */
+export async function billingInvoicesCommand(options) {
+    try {
+        const teamId = getCurrentTeamId();
+        if (!teamId) {
+            ui.error('No team selected. Run `nimbus team switch <team-id>` first.');
+            return;
+        }
+        ui.startSpinner({ message: 'Fetching invoices...' });
+        const invoices = await billingClient.getInvoices(teamId, options.limit || 10);
+        ui.stopSpinnerSuccess(`Found ${invoices.length} invoices`);
+        if (options.json) {
+            console.log(JSON.stringify(invoices, null, 2));
+            return;
+        }
+        if (invoices.length === 0) {
+            ui.info('No invoices found');
+            return;
+        }
+        ui.newLine();
+        ui.table({
+            columns: [
+                { key: 'number', header: 'Invoice #' },
+                { key: 'date', header: 'Date' },
+                { key: 'amount', header: 'Amount' },
+                { key: 'status', header: 'Status' },
+            ],
+            data: invoices.map(inv => ({
+                number: inv.number,
+                date: new Date(inv.createdAt).toLocaleDateString(),
+                amount: `$${(inv.amountDue / 100).toFixed(2)} ${inv.currency.toUpperCase()}`,
+                status: inv.status,
+            })),
+        });
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to get invoices');
+        ui.error(error.message);
+    }
+}
+/**
+ * Billing cancel command
+ */
+export async function billingCancelCommand() {
+    try {
+        const teamId = getCurrentTeamId();
+        if (!teamId) {
+            ui.error('No team selected. Run `nimbus team switch <team-id>` first.');
+            return;
+        }
+        ui.startSpinner({ message: 'Canceling subscription...' });
+        const status = await billingClient.cancel(teamId);
+        ui.stopSpinnerSuccess('Subscription canceled');
+        ui.newLine();
+        ui.warning(`Your subscription will end on ${new Date(status.currentPeriodEnd).toLocaleDateString()}`);
+        ui.info('You will retain access until then.');
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to cancel');
+        ui.error(error.message);
+    }
+}
+/**
+ * Main billing command dispatcher
+ */
+export async function billingCommand(subcommand, args) {
+    switch (subcommand) {
+        case 'status':
+        case undefined:
+            await billingStatusCommand(parseBillingStatusOptions(args));
+            break;
+        case 'upgrade':
+            await billingUpgradeCommand(parseBillingUpgradeOptions(args));
+            break;
+        case 'invoices':
+            await billingInvoicesCommand(parseBillingInvoicesOptions(args));
+            break;
+        case 'cancel':
+            await billingCancelCommand();
+            break;
+        default:
+            ui.error(`Unknown billing command: ${subcommand}`);
+            ui.newLine();
+            ui.info('Available billing commands:');
+            ui.print('  nimbus billing status          - Show billing status');
+            ui.print('  nimbus billing upgrade <plan>  - Upgrade plan (pro|enterprise)');
+            ui.print('  nimbus billing invoices        - List invoices');
+            ui.print('  nimbus billing cancel          - Cancel subscription');
+    }
+}

package/dist/src/commands/chat.js

@@ -0,0 +1,259 @@
+/**
+ * Chat Command
+ *
+ * Interactive chat mode with LLM streaming and infrastructure generation
+ */
+import { startChat } from '../ui';
+import { AuthStore } from '../auth/store';
+import { ui } from '../wizard/ui';
+import { historyManager } from '../history';
+/**
+ * Chat command handler
+ *
+ * Usage:
+ *   nimbus chat                    - Start interactive chat (Ink TUI)
+ *   nimbus chat --model gpt-4o     - Use specific model
+ *   nimbus chat -m "Hello"         - Send single message (non-interactive)
+ *   nimbus chat --ui=readline      - Use simple readline interface (no React/Ink)
+ */
+export async function chatCommand(options = {}) {
+    // Check for NIMBUS.md and suggest init if missing (non-blocking)
+    if (!options.nonInteractive && !options.message) {
+        try {
+            const fs = await import('node:fs');
+            const path = await import('node:path');
+            const nimbusPath = path.default.join(process.cwd(), 'NIMBUS.md');
+            if (!fs.default.existsSync(nimbusPath)) {
+                ui.print(ui.dim('Tip: No NIMBUS.md found. Run `nimbus init` to set up project context for better results.'));
+                ui.newLine();
+            }
+        }
+        catch {
+            // Non-critical, ignore
+        }
+    }
+    // Pre-flight: verify at least one LLM provider is available
+    try {
+        const { getAppContext } = await import('../app');
+        const ctx = getAppContext();
+        if (ctx?.router && ctx.router.getAvailableProviders().length === 0) {
+            ui.newLine();
+            ui.error('No LLM provider configured.');
+            ui.newLine();
+            ui.print('Set up a provider using one of these methods:');
+            ui.print(`  ${ui.bold('nimbus login')}           — interactive setup wizard`);
+            ui.print(`  ${ui.bold('export ANTHROPIC_API_KEY=sk-ant-...')}  — environment variable`);
+            ui.print(`  ${ui.bold('export OPENAI_API_KEY=sk-...')}         — environment variable`);
+            ui.newLine();
+            return;
+        }
+    }
+    catch {
+        // Pre-flight is non-critical — let it fail later with a real error
+    }
+    // Resolve --continue: look up the most recent session ID
+    let resumeSessionId;
+    if (options.continue) {
+        try {
+            const { SessionManager } = await import('../sessions/manager');
+            const sessionManager = SessionManager.getInstance();
+            const recent = sessionManager.list();
+            if (recent.length > 0) {
+                resumeSessionId = recent[0].id;
+            }
+            else {
+                ui.print(ui.dim('No previous session found. Starting a new session.'));
+                ui.newLine();
+            }
+        }
+        catch {
+            // Session lookup is non-critical — fall through to a fresh session
+        }
+    }
+    // Default to Ink TUI, fall back to readline if unavailable or explicitly requested.
+    // If stdin is not a TTY (piped input), skip Ink and use readline mode.
+    if (options.ui !== 'readline' && process.stdin.isTTY) {
+        try {
+            const { startInkChat } = await import('../ui/ink/index');
+            await startInkChat({
+                model: options.model,
+                systemPrompt: options.systemPrompt,
+                showTokenCount: options.showTokenCount,
+                resumeSessionId,
+                initialPrompt: options.initialPrompt,
+                mode: options.mode,
+            });
+            return;
+        }
+        catch {
+            // Ink TUI unavailable (compiled binary without React/Ink) — fall back to readline
+            ui.print(ui.dim('Using readline mode (same features, simpler UI). For the rich TUI, run: bun src/nimbus.ts'));
+            ui.newLine();
+        }
+    }
+    else if (!process.stdin.isTTY && options.ui !== 'readline') {
+        // Piped stdin detected — inform user
+        ui.print(ui.dim('Non-interactive terminal detected, using readline mode.'));
+        ui.newLine();
+    }
+    const startTime = Date.now();
+    const entry = historyManager.addEntry('chat', [], {
+        model: options.model,
+        persona: options.persona,
+    });
+    try {
+        // Get default model from auth store if not specified
+        if (!options.model) {
+            const authStore = new AuthStore();
+            const status = authStore.getStatus();
+            // Find the default provider's model
+            const defaultProviderInfo = status.providers.find(p => p.name === status.defaultProvider);
+            options.model = defaultProviderInfo?.model;
+        }
+        // Read persona from config if not specified
+        if (!options.persona || !options.verbosity) {
+            try {
+                const { configManager } = await import('../config/manager');
+                if (!options.persona) {
+                    const mode = configManager.get('persona.mode');
+                    if (mode) {
+                        options.persona = mode;
+                    }
+                }
+                if (!options.verbosity) {
+                    const verbosity = configManager.get('persona.verbosity');
+                    if (verbosity) {
+                        options.verbosity = verbosity;
+                    }
+                }
+            }
+            catch {
+                // Config read failure is non-critical
+            }
+        }
+        const persona = options.persona || 'assistant';
+        const verbosity = options.verbosity || 'normal';
+        // Non-interactive mode: send single message
+        if (options.nonInteractive || options.message) {
+            if (!options.message) {
+                ui.error('Message is required in non-interactive mode. Use --message or -m.');
+                process.exit(1);
+            }
+            await sendSingleMessage(options.message, options, persona, verbosity);
+            historyManager.completeEntry(entry.id, 'success', Date.now() - startTime);
+            return;
+        }
+        // Interactive mode: start chat UI
+        const chatOptions = {
+            model: options.model,
+            systemPrompt: options.systemPrompt || getPersonaSystemPrompt(persona, verbosity),
+            showTokenCount: options.showTokenCount ?? false,
+            resumeSessionId,
+        };
+        await startChat(chatOptions);
+        historyManager.completeEntry(entry.id, 'success', Date.now() - startTime);
+    }
+    catch (error) {
+        historyManager.completeEntry(entry.id, 'failure', Date.now() - startTime, {
+            error: error.message,
+        });
+        // Detect auth/API key errors and suggest re-onboarding
+        const errMsg = error.message || String(error);
+        if (/auth|api.?key|unauthorized|forbidden|401|403|invalid.*key/i.test(errMsg)) {
+            ui.newLine();
+            ui.error('LLM authentication failed. Your API key may be invalid or expired.');
+            ui.newLine();
+            ui.print('To reconfigure:');
+            ui.print(`  ${ui.bold('nimbus login')}  — re-run the setup wizard`);
+            ui.print(`  ${ui.bold('export ANTHROPIC_API_KEY=sk-ant-...')}  — set a new key`);
+            ui.newLine();
+            return;
+        }
+        throw error;
+    }
+}
+/**
+ * Send a single message and display the response (non-interactive mode)
+ *
+ * Uses the full agent loop so that tool-calling is available even in
+ * non-interactive / single-message mode (`nimbus chat -m "..."`).
+ */
+async function sendSingleMessage(message, options, _persona, _verbosity) {
+    const { getAppContext } = await import('../app');
+    const { runAgentLoop } = await import('../agent/loop');
+    const { defaultToolRegistry } = await import('../tools/schemas/types');
+    const ctx = getAppContext();
+    if (!ctx) {
+        ui.error('App not initialised. Cannot send message.');
+        process.exit(1);
+    }
+    const outputParts = [];
+    try {
+        const result = await runAgentLoop(message, [], {
+            router: ctx.router,
+            toolRegistry: defaultToolRegistry,
+            mode: 'build',
+            model: options.model,
+            cwd: process.cwd(),
+            onText: text => {
+                process.stdout.write(text);
+                outputParts.push(text);
+            },
+            onToolCallStart: toolCall => {
+                process.stderr.write(`\n[Tool: ${toolCall.name}]\n`);
+            },
+            onToolCallEnd: (_toolCall, toolResult) => {
+                if (toolResult.isError) {
+                    process.stderr.write(`[Error: ${toolResult.error}]\n`);
+                }
+            },
+        });
+        // Final newline
+        if (outputParts.length > 0) {
+            console.log('');
+        }
+        if (result.interrupted) {
+            ui.info('Operation interrupted.');
+        }
+    }
+    catch (error) {
+        ui.error(error.message || 'Failed to get response');
+        process.exit(1);
+    }
+}
+/**
+ * Build a persona-aware system prompt for Nimbus chat.
+ *
+ * @param persona - The persona mode that controls tone and style
+ * @param verbosity - The verbosity level that controls response length
+ * @returns A complete system prompt string
+ */
+function getPersonaSystemPrompt(persona, verbosity) {
+    // Base identity shared across all personas
+    const baseIdentity = `You are Nimbus, an AI-powered DevOps engineering agent. You help users with:
+
+- Infrastructure as Code (Terraform, Kubernetes, Helm)
+- Cloud provider operations (AWS, GCP, Azure)
+- Kubernetes operations and configurations
+- DevOps best practices and CI/CD pipelines
+- Troubleshooting infrastructure issues`;
+    // Persona-specific instructions
+    const personaInstructions = {
+        professional: `Maintain a formal, structured, and enterprise-focused tone at all times. Use bullet points and numbered lists to organize information clearly. Prefer formal language and avoid colloquialisms. Frame recommendations in terms of business impact, compliance, and operational excellence. When proposing changes, present them as structured plans with clear rationale, risk assessment, and rollback considerations.`,
+        assistant: `Be friendly and conversational while remaining helpful and accurate. Explain concepts in an approachable way, breaking down complex topics so they are easy to understand. When suggesting infrastructure code, walk through the reasoning behind each decision. If you need more information to provide accurate help, ask clarifying questions. Offer encouragement and context to help users learn as they go.`,
+        expert: `Be technical and concise. Assume the user has deep knowledge of cloud infrastructure, networking, and DevOps practices. Skip introductory explanations and get straight to the solution. Include advanced patterns, edge cases, and performance considerations where relevant. Reference specific API versions, provider documentation, and known gotchas. Prefer code-first responses with terse inline comments over lengthy prose.`,
+    };
+    // Verbosity-level instructions
+    const verbosityInstructions = {
+        minimal: `Keep responses brief and to the point. Omit preamble and unnecessary context. Provide the shortest correct answer, using code blocks or bullet points when possible. Avoid repeating the question or restating what the user already knows.`,
+        normal: `Provide balanced responses that include enough context to be useful without being verbose. Include a brief explanation alongside code or commands. Mention important caveats or prerequisites when relevant, but do not over-explain.`,
+        detailed: `Provide comprehensive responses with thorough explanations. Include code examples, usage patterns, and alternative approaches. Explain trade-offs, link to relevant best practices, and suggest next steps. Where applicable, show before-and-after comparisons and provide context on why a particular approach is preferred.`,
+    };
+    return [
+        baseIdentity,
+        '',
+        personaInstructions[persona],
+        '',
+        verbosityInstructions[verbosity],
+    ].join('\n');
+}