@build-astron-co/nimbus 0.4.1 → 0.4.3

package/src/ui/streaming.ts

@@ -1,176 +0,0 @@
-/**
- * Streaming Text Display
- *
- * Utilities for displaying streaming LLM responses in the terminal
- */
-
-import { ui } from '../wizard/ui';
-
-export interface StreamingDisplayOptions {
-  /** Prefix to show before the response (e.g., "Nimbus: ") */
-  prefix?: string;
-  /** Color for the prefix */
-  prefixColor?: string;
-  /** Whether to show a cursor while streaming */
-  showCursor?: boolean;
-  /** Character to use as cursor */
-  cursorChar?: string;
-}
-
-/**
- * StreamingDisplay handles real-time text output from LLM responses
- */
-export class StreamingDisplay {
-  private options: Required<StreamingDisplayOptions>;
-  private buffer: string = '';
-  private lineStarted: boolean = false;
-  private cursorInterval?: ReturnType<typeof setTimeout>;
-
-  constructor(options: StreamingDisplayOptions = {}) {
-    this.options = {
-      prefix: options.prefix || '',
-      prefixColor: options.prefixColor || 'blue',
-      showCursor: options.showCursor ?? true,
-      cursorChar: options.cursorChar || '|',
-    };
-  }
-
-  /**
-   * Start a new streaming response
-   */
-  start(): void {
-    this.buffer = '';
-    this.lineStarted = false;
-
-    // Print the prefix
-    if (this.options.prefix) {
-      ui.write(
-        ui.color(this.options.prefix, this.options.prefixColor as Parameters<typeof ui.color>[1])
-      );
-    }
-
-    this.lineStarted = true;
-
-    // Start cursor blink if enabled
-    if (this.options.showCursor) {
-      this.startCursor();
-    }
-  }
-
-  /**
-   * Append text to the streaming display
-   */
-  append(text: string): void {
-    // Stop cursor while writing
-    this.stopCursor();
-
-    // Handle newlines in the text
-    const lines = text.split('\n');
-
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-
-      if (i > 0) {
-        // This is after a newline
-        ui.print(''); // End current line
-        this.lineStarted = false;
-      }
-
-      if (line) {
-        if (!this.lineStarted) {
-          // Add indentation for continuation lines
-          ui.write('  '); // Indent to align with prefix
-          this.lineStarted = true;
-        }
-        ui.write(line);
-      }
-
-      this.buffer += (i > 0 ? '\n' : '') + line;
-    }
-
-    // Restart cursor
-    if (this.options.showCursor) {
-      this.startCursor();
-    }
-  }
-
-  /**
-   * Complete the streaming display
-   */
-  complete(): string {
-    this.stopCursor();
-
-    // Ensure we end on a new line
-    if (this.lineStarted) {
-      ui.print('');
-    }
-
-    return this.buffer;
-  }
-
-  /**
-   * Handle an error during streaming
-   */
-  error(message: string): void {
-    this.stopCursor();
-
-    if (this.lineStarted) {
-      ui.print('');
-    }
-
-    ui.error(message);
-  }
-
-  private startCursor(): void {
-    if (this.cursorInterval) {
-      return;
-    }
-
-    let visible = true;
-    this.cursorInterval = setInterval(() => {
-      if (visible) {
-        ui.write(ui.dim(this.options.cursorChar));
-      } else {
-        // Backspace to remove cursor
-        ui.write('\b \b');
-      }
-      visible = !visible;
-    }, 500);
-  }
-
-  private stopCursor(): void {
-    if (this.cursorInterval) {
-      clearInterval(this.cursorInterval);
-      this.cursorInterval = undefined;
-      // Clear any remaining cursor character
-      ui.write('\b \b');
-    }
-  }
-}
-
-/**
- * Simple streaming helper for one-off usage
- */
-export async function displayStreaming(
-  generator: AsyncGenerator<{ content?: string; type: string }>,
-  options: StreamingDisplayOptions = {}
-): Promise<string> {
-  const display = new StreamingDisplay(options);
-  display.start();
-
-  try {
-    for await (const chunk of generator) {
-      if (chunk.type === 'content' && chunk.content) {
-        display.append(chunk.content);
-      } else if (chunk.type === 'error') {
-        display.error((chunk as { message?: string }).message || 'Unknown error');
-        return '';
-      }
-    }
-
-    return display.complete();
-  } catch (error: unknown) {
-    display.error(error instanceof Error ? error.message : 'Streaming failed');
-    return '';
-  }
-}

package/src/ui/theme.ts

@@ -1,104 +0,0 @@
-/**
- * Theme system for Nimbus TUI.
- *
- * Provides named color themes (dark, light) that can be switched at runtime.
- * Components should import `activeTheme` and use its color properties instead
- * of hardcoding color strings.
- *
- * Theme preference is persisted to ~/.nimbus/config.yaml.
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface Theme {
-  name: string;
-  /** Primary accent color (headers, prompts). */
-  primary: string;
-  /** Secondary accent color (highlights). */
-  secondary: string;
-  /** Success / create indicator. */
-  success: string;
-  /** Warning indicator. */
-  warning: string;
-  /** Error / destroy indicator. */
-  error: string;
-  /** Dim text and separators. */
-  muted: string;
-  /** Border color. */
-  border: string;
-}
-
-// ---------------------------------------------------------------------------
-// Built-in themes
-// ---------------------------------------------------------------------------
-
-export const THEMES: Record<string, Theme> = {
-  dark: {
-    name: 'dark',
-    primary: 'cyan',
-    secondary: 'blue',
-    success: 'green',
-    warning: 'yellow',
-    error: 'red',
-    muted: 'gray',
-    border: 'gray',
-  },
-  light: {
-    name: 'light',
-    primary: 'blue',
-    secondary: 'magenta',
-    success: 'green',
-    warning: 'yellow',
-    error: 'red',
-    muted: 'gray',
-    border: 'white',
-  },
-};
-
-// ---------------------------------------------------------------------------
-// Active theme (mutable singleton)
-// ---------------------------------------------------------------------------
-
-export let activeTheme: Theme = THEMES.dark;
-
-/**
- * Switch the active theme by name.
- * Falls back to `dark` if the name is not recognized.
- * Persists the chosen theme name to ~/.nimbus/config.yaml.
- */
-export function setTheme(name: string): void {
-  activeTheme = THEMES[name] ?? THEMES.dark;
-  // Persist to config file
-  try {
-    const configDir = path.join(os.homedir(), '.nimbus');
-    const configFile = path.join(configDir, 'config.yaml');
-    fs.mkdirSync(configDir, { recursive: true });
-    let config = '';
-    try {
-      config = fs.readFileSync(configFile, 'utf-8');
-    } catch {
-      /* new file */
-    }
-    if (config.includes('theme:')) {
-      config = config.replace(/^theme:.*$/m, `theme: ${name}`);
-    } else {
-      config = config ? `${config.trim()}\ntheme: ${name}\n` : `theme: ${name}\n`;
-    }
-    fs.writeFileSync(configFile, config, 'utf-8');
-  } catch {
-    /* ignore FS errors */
-  }
-}
-
-/**
- * List all available theme names.
- */
-export function listThemes(): string[] {
-  return Object.keys(THEMES);
-}

package/src/ui/types.ts

@@ -1,75 +0,0 @@
-/**
- * Shared types for Nimbus TUI components.
- *
- * These interfaces are consumed by every Ink component in the UI layer and by
- * the orchestration logic that feeds data into the rendering tree.
- */
-
-/** The three operational modes of the Nimbus agent. */
-export type AgentMode = 'plan' | 'build' | 'deploy';
-
-/** A single chat message displayed in the message list. */
-export interface UIMessage {
-  id: string;
-  role: 'user' | 'assistant' | 'system';
-  content: string;
-  timestamp: Date;
-  toolCalls?: UIToolCall[];
-  /**
-   * Pre-computed content segments (text + code blocks) produced by parseContent().
-   * When set, MessageList skips the parsing step for this message entirely.
-   * Kept on UIMessage (not LLMMessage) to maintain a clean LLM/UI boundary.
-   */
-  _precomputedSegments?: Array<{ type: 'text' | 'code'; content: string; language?: string }>;
-}
-
-/** A tool invocation attached to an assistant message. */
-export interface UIToolCall {
-  id: string;
-  name: string;
-  input: Record<string, unknown>;
-  result?: { output: string; isError: boolean };
-  status: 'pending' | 'running' | 'completed' | 'failed';
-  /** Elapsed wall-clock time in milliseconds. */
-  duration?: number;
-  /** Unix timestamp (Date.now()) when the tool call started, for elapsed timer. */
-  startTime?: number;
-  /** Live stdout/stderr lines streamed during execution (Gap 1). */
-  streamingOutput?: string;
-}
-
-/** Metadata about the current agent session. */
-export interface SessionInfo {
-  id: string;
-  model: string;
-  mode: AgentMode;
-  tokenCount: number;
-  maxTokens: number;
-  costUSD: number;
-  snapshotCount: number;
-  /** Active kubectl context (G1). */
-  kubectlContext?: string;
-  /** Active Terraform workspace (G1). */
-  terraformWorkspace?: string;
-  /** Infra cost delta string from infracost (G15). */
-  infraCostDelta?: string;
-  /** LLM connectivity health (GAP-2). */
-  llmHealth?: 'checking' | 'ok' | 'error';
-}
-
-/** A single resource-level change shown in the deploy preview. */
-export interface DeployChange {
-  action: 'create' | 'modify' | 'destroy' | 'replace';
-  resourceType: string;
-  resourceName: string;
-  details?: string;
-}
-
-/** Full deploy preview data rendered before apply. */
-export interface DeployPreviewData {
-  tool: string;
-  changes: DeployChange[];
-  costImpact?: string;
-  blastRadius?: string;
-  affectedServices?: string[];
-}

package/src/utils/analytics.ts

@@ -1,72 +0,0 @@
-/**
- * PostHog Analytics Integration
- *
- * Lightweight analytics wrapper that sends events to PostHog.
- * Operates as a complete no-op when POSTHOG_API_KEY is not set.
- */
-
-export interface AnalyticsEvent {
-  event: string;
-  properties?: Record<string, unknown>;
-}
-
-export class Analytics {
-  private apiKey: string | undefined;
-  private host: string;
-
-  constructor() {
-    this.apiKey = process.env.POSTHOG_API_KEY;
-    this.host = process.env.POSTHOG_HOST || 'https://app.posthog.com';
-  }
-
-  get enabled(): boolean {
-    return !!this.apiKey;
-  }
-
-  async trackEvent(event: string, properties?: Record<string, unknown>): Promise<void> {
-    if (!this.enabled) {
-      return;
-    }
-
-    try {
-      await fetch(`${this.host}/capture/`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          api_key: this.apiKey,
-          event,
-          properties: {
-            ...properties,
-            timestamp: new Date().toISOString(),
-          },
-          distinct_id: properties?.userId || 'anonymous',
-        }),
-      });
-    } catch {
-      // Fire-and-forget -- never throw from analytics
-    }
-  }
-
-  async identifyUser(userId: string, properties?: Record<string, unknown>): Promise<void> {
-    if (!this.enabled) {
-      return;
-    }
-
-    try {
-      await fetch(`${this.host}/capture/`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          api_key: this.apiKey,
-          event: '$identify',
-          distinct_id: userId,
-          properties,
-        }),
-      });
-    } catch {
-      // Fire-and-forget
-    }
-  }
-}
-
-export const analytics = new Analytics();

package/src/utils/cost-warning.ts

@@ -1,27 +0,0 @@
-/**
- * Cost Warning Utility
- *
- * Shows informational cost warnings before destructive operations.
- * Best-effort: silently skips on any failure.
- */
-
-import { ui } from '../wizard/ui';
-import { CostEstimator } from '../commands/cost/estimator';
-
-/**
- * Show an informational cost warning before a destructive operation.
- * Calls CostEstimator.estimateDirectory() and displays the estimated
- * monthly cost impact as a negative value (savings from destroying).
- * Wrapped in try/catch — never throws.
- */
-export async function showDestructionCostWarning(directory: string): Promise<void> {
-  try {
-    const estimate = await CostEstimator.estimateDirectory(directory);
-
-    if (estimate.totalMonthlyCost > 0) {
-      ui.warning(`Estimated monthly cost impact: -$${estimate.totalMonthlyCost.toFixed(2)}/month`);
-    }
-  } catch {
-    // Best-effort — silently skip if estimation fails
-  }
-}

package/src/utils/env.ts

@@ -1,46 +0,0 @@
-import { ConfigurationError } from './errors';
-
-export function getEnv(key: string, defaultValue?: string): string {
-  const value = process.env[key];
-  if (value === undefined) {
-    if (defaultValue !== undefined) {
-      return defaultValue;
-    }
-    throw new ConfigurationError(`Environment variable ${key} is required but not set`, 'nimbus', {
-      key,
-    });
-  }
-  return value;
-}
-
-export function getEnvOptional(key: string): string | undefined {
-  return process.env[key];
-}
-
-export function getEnvNumber(key: string, defaultValue?: number): number {
-  const value = process.env[key];
-  if (value === undefined) {
-    if (defaultValue !== undefined) {
-      return defaultValue;
-    }
-    throw new ConfigurationError(`Environment variable ${key} is required but not set`, 'nimbus', {
-      key,
-    });
-  }
-  const parsed = parseInt(value, 10);
-  if (isNaN(parsed)) {
-    throw new ConfigurationError(`Environment variable ${key} must be a valid number`, 'nimbus', {
-      key,
-      value,
-    });
-  }
-  return parsed;
-}
-
-export function getEnvBoolean(key: string, defaultValue: boolean = false): boolean {
-  const value = process.env[key];
-  if (value === undefined) {
-    return defaultValue;
-  }
-  return value.toLowerCase() === 'true' || value === '1';
-}

package/src/utils/errors.ts

@@ -1,69 +0,0 @@
-export interface ServiceError {
-  code: string;
-  message: string;
-  service: string;
-  timestamp: string;
-  details?: unknown;
-  stack?: string;
-}
-
-/**
- * Base Nimbus Error
- */
-export class NimbusError extends Error {
-  code: string;
-  service: string;
-  timestamp: string;
-  details?: unknown;
-
-  constructor(message: string, code: string, service: string, details?: unknown) {
-    super(message);
-    this.name = 'NimbusError';
-    this.code = code;
-    this.service = service;
-    this.timestamp = new Date().toISOString();
-    this.details = details;
-  }
-
-  toJSON(): ServiceError {
-    return {
-      code: this.code,
-      message: this.message,
-      service: this.service,
-      timestamp: this.timestamp,
-      details: this.details,
-      stack: this.stack,
-    };
-  }
-}
-
-export class ValidationError extends NimbusError {
-  constructor(message: string, service: string, details?: unknown) {
-    super(message, 'VALIDATION_ERROR', service, details);
-    this.name = 'ValidationError';
-  }
-}
-
-export class ServiceUnavailableError extends NimbusError {
-  constructor(serviceName: string, details?: unknown) {
-    super(`Service ${serviceName} is unavailable`, 'SERVICE_UNAVAILABLE', 'nimbus', details);
-    this.name = 'ServiceUnavailableError';
-  }
-}
-
-export class TimeoutError extends NimbusError {
-  constructor(operation: string, service: string, timeoutMs: number) {
-    super(`Operation ${operation} timed out after ${timeoutMs}ms`, 'TIMEOUT_ERROR', service, {
-      operation,
-      timeoutMs,
-    });
-    this.name = 'TimeoutError';
-  }
-}
-
-export class ConfigurationError extends NimbusError {
-  constructor(message: string, service: string, details?: unknown) {
-    super(message, 'CONFIGURATION_ERROR', service, details);
-    this.name = 'ConfigurationError';
-  }
-}

package/src/utils/event-bus.ts

@@ -1,38 +0,0 @@
-import { EventEmitter } from 'node:events';
-
-export interface NimbusEvent {
-  type: string;
-  source: string;
-  timestamp: string;
-  data: Record<string, unknown>;
-}
-
-export type EventHandler = (event: NimbusEvent) => void | Promise<void>;
-
-class NimbusEventBus {
-  private emitter = new EventEmitter();
-
-  constructor() {
-    this.emitter.setMaxListeners(50);
-  }
-
-  publish(event: NimbusEvent): void {
-    this.emitter.emit(event.type, event);
-    this.emitter.emit('*', event);
-  }
-
-  subscribe(eventType: string, handler: EventHandler): () => void {
-    this.emitter.on(eventType, handler);
-    return () => this.emitter.off(eventType, handler);
-  }
-
-  once(eventType: string, handler: EventHandler): void {
-    this.emitter.once(eventType, handler);
-  }
-
-  removeAllListeners(eventType?: string): void {
-    this.emitter.removeAllListeners(eventType);
-  }
-}
-
-export const eventBus = new NimbusEventBus();

package/src/utils/index.ts

@@ -1,24 +0,0 @@
-// Logger
-export { logger, Logger } from './logger';
-export type { LogLevel } from './logger';
-
-// Errors
-export * from './errors';
-
-// Validation
-export * from './validation';
-
-// Environment helpers
-export * from './env';
-
-// Service authentication
-export * from './service-auth';
-
-// Rate limiting
-export * from './rate-limiter';
-
-// Event bus
-export * from './event-bus';
-
-// Analytics (PostHog)
-export * from './analytics';