@build-astron-co/nimbus 0.3.0 → 0.4.1

package/CHANGELOG.md

@@ -0,0 +1,100 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2025-06-15
+
+### Added
+
+#### Core Platform
+
+- Microservices architecture with 18 services running on Bun runtime
+- Core Engine Service with task management, plan generation, and execution
+- LLM Service with multi-provider support (Anthropic, Google, Ollama)
+- Generator Service for IaC code generation with questionnaire-driven workflows
+- State Service for configuration, history, conversations, artifacts, and
+  templates
+- WebSocket support for real-time streaming on core engine, LLM, and generator
+  services
+
+#### CLI
+
+- Interactive AI chat with syntax-highlighted code output
+- Terraform commands: plan, apply, destroy, import, validate, fmt, state
+  management
+- Kubernetes commands: get, apply, delete, logs, exec, scale, rollout,
+  port-forward
+- Helm commands: install, upgrade, uninstall, list, rollback, template, lint
+- Git commands: status, clone, add, commit, push, pull, branch, merge, tag
+- File system commands: read, write, search, tree, diff, copy, move
+- GitHub integration: PRs, issues, releases, Actions workflows
+- AI-driven Terraform generation with conversational and questionnaire modes
+- Infrastructure cost estimation for Terraform plans
+- Doctor command for dependency verification
+- Login/logout with device code flow authentication
+- Telemetry integration (opt-in) via PostHog
+
+#### Cloud Provider Support
+
+- AWS Tools Service: infrastructure discovery across 10+ services, Terraform
+  generation
+- GCP Tools Service: Compute Engine, Cloud Storage, GKE, IAM, Cloud Functions,
+  VPC operations
+- Azure Tools Service: VMs, Storage, AKS, IAM, Functions, Virtual Network
+  operations
+- Infrastructure discovery with real-time progress streaming for all three
+  providers
+- Terraform code generation from discovered cloud resources
+
+#### DevOps Tools
+
+- Git Tools Service for local repository operations via simple-git
+- GitHub Tools Service for GitHub API operations via Octokit (PRs, issues,
+  Actions, releases)
+- Terraform Tools Service for full Terraform CLI lifecycle management
+- Kubernetes Tools Service for kubectl operations and cluster management
+- Helm Tools Service for chart and release lifecycle management
+- File System Tools Service with sensitive file protection
+
+#### Team and Enterprise
+
+- Auth Service with device code flow and token validation
+- Team Service with CRUD operations, member invitations, and role management
+- Billing Service with Stripe integration, subscriptions, and usage tracking
+- Audit Service with compliance logging, filterable queries, and CSV/JSON export
+- RBAC-based access control for team operations
+
+### Security
+
+- Service-to-service authentication middleware across all services
+- Rate limiting on all HTTP endpoints (configurable per service)
+- Sensitive file protection in file system operations
+- Input validation and sanitization on all API routes
+- Stripe webhook signature verification
+- Credential encryption for stored cloud provider credentials
+- No credentials logged or persisted in plain text
+
+### Infrastructure
+
+- Bun monorepo with workspace-based dependency management
+- Docker Compose configuration for local development
+- Dockerfiles for all services including GCP and Azure tools
+- CI/CD pipeline via GitHub Actions with type checking, linting, and tests
+- Health check endpoints on every service
+- Shared packages: clients, types, and utils across all services
+
+### Developer Experience
+
+- Swagger UI documentation on all tool services (`/swagger`)
+- OpenAPI 3.0 specs served at `/api/openapi.json` on each service
+- README documentation for every service
+- Distributed tracing support via shared tracing utility
+- Event bus for inter-service communication
+- Shared REST client with service discovery
+- Consistent error response format across all services
+  (`{ success, data/error }`)
+- Start-all script for launching the full platform locally

package/README.md

@@ -5,8 +5,8 @@
 [![GitHub release](https://img.shields.io/github/v/release/the-ai-project-co/nimbus)](https://github.com/the-ai-project-co/nimbus/releases)
 [![CI](https://github.com/the-ai-project-co/nimbus/actions/workflows/ci.yml/badge.svg)](https://github.com/the-ai-project-co/nimbus/actions)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.3-blue.svg)](https://www.typescriptlang.org/)
-[![Bun](https://img.shields.io/badge/Bun-%E2%89%A51.0-f472b6.svg)](https://bun.sh/)
-[![Tests](https://img.shields.io/badge/tests-693%20passing-brightgreen.svg)](https://github.com/the-ai-project-co/nimbus/actions)
+[![Node.js](https://img.shields.io/badge/Node.js-%E2%89%A518-brightgreen.svg)](https://nodejs.org/)
+[![Tests](https://img.shields.io/badge/tests-1408%20passing-brightgreen.svg)](https://github.com/the-ai-project-co/nimbus/actions)
 
 > AI-powered cloud engineering agent for your terminal
 
@@ -83,8 +83,6 @@ three-mode safety system that separates reading, building, and deploying.
 ```bash
 # Install
 npm install -g @build-astron-co/nimbus
-# or
-bun install -g @build-astron-co/nimbus
 # or via Homebrew
 brew tap the-ai-project-co/tap
 brew install nimbus
@@ -104,23 +102,13 @@ the interactive chat.
 
 ## Installation
 
-### Bun (recommended -- fastest, native SQLite)
-
-```bash
-bun install -g @build-astron-co/nimbus
-```
-
-Bun provides the best experience: native `bun:sqlite` for state management,
-faster startup, and the full Ink TUI out of the box.
-
-### npm
+### npm (recommended)
 
 ```bash
 npm install -g @build-astron-co/nimbus
 ```
 
-Works with Node.js >= 18. Uses `better-sqlite3` as the SQLite backend when
-running under Node.
+Works with Node.js >= 18. Uses `better-sqlite3` as the SQLite backend.
 
 ### Homebrew (macOS / Linux)
 
@@ -490,7 +478,7 @@ nimbus init --quiet      # suppress console output
 
 ### Prerequisites
 
-- [Bun](https://bun.sh/) v1.0 or higher
+- Node.js >= 18
 - Git
 
 ### Setup
@@ -498,56 +486,50 @@ nimbus init --quiet      # suppress console output
 ```bash
 git clone https://github.com/the-ai-project-co/nimbus.git
 cd nimbus
-bun install
+npm install
 ```
 
 ### Run from source
 
 ```bash
 # Run directly
-bun src/nimbus.ts
+npm run nimbus
 
 # Run with arguments
-bun src/nimbus.ts --help
-bun src/nimbus.ts chat
-bun src/nimbus.ts ask "explain this project"
-
-# Or use the npm script
-bun run nimbus -- --help
+npm run nimbus -- --help
+npm run nimbus -- chat
+npm run nimbus -- ask "explain this project"
 ```
 
 ### Test
 
 ```bash
-# Run all tests (693 tests)
-bun test src/__tests__/
+# Run all tests (1408 tests)
+npm test
 
 # Run with coverage
-bun test src/__tests__/ --coverage
+npm run test:coverage
 
 # Watch mode
-bun test src/__tests__/ --watch
+npm run test:watch
 ```
 
 ### Lint and format
 
 ```bash
-bun run lint
-bun run format
-bun run type-check
+npm run lint
+npm run format
+npm run type-check
 ```
 
 ### Build
 
 ```bash
 # Build standalone binary for current platform
-bun src/build.ts
-
-# Build for all platforms
-bun src/build.ts --all
-
-# Or use the shell script
 ./scripts/build-binary.sh
+
+# Or
+npm run build
 ```
 
 The binary is output to `dist/nimbus` (~68 MB, bundles the Bun runtime).
@@ -556,15 +538,15 @@ The binary is output to `dist/nimbus` (~68 MB, bundles the Bun runtime).
 
 ## Architecture
 
-Nimbus is a single embedded binary built with [Bun](https://bun.sh/). All
-functionality runs in-process -- there are no HTTP microservices, no Docker
+Nimbus runs on Node.js >= 18 (with optional Bun support for compiled binaries).
+All functionality runs in-process -- there are no HTTP microservices, no Docker
 containers, and no external orchestrators. The entire application is a single
 TypeScript process that manages LLM routing, tool execution, state persistence,
 and the TUI.
 
 ```
 src/
-  nimbus.ts          Entry point (shebang: #!/usr/bin/env bun)
+  nimbus.ts          Entry point (shebang: #!/usr/bin/env node via tsx)
   cli.ts             CLI command router
   app.ts             App lifecycle (lazy DB + LLM router init)
   version.ts         Version and build date constants
@@ -593,7 +575,7 @@ src/
   watcher/           Filesystem watcher for live file tracking
 
   build.ts           Binary build script
-  __tests__/         693 tests
+  __tests__/         1408 tests
 ```
 
 ### Key design decisions

package/bin/nimbus.cmd

@@ -0,0 +1,41 @@
+@echo off
+:: Nimbus CLI launcher for Windows (CMD / PowerShell).
+:: Resolves the package root relative to this script's location so it works
+:: when npm installs the bin entry as a junction/shim in node_modules/.bin/.
+
+setlocal enabledelayedexpansion
+
+:: Locate the package root (one level up from this bin\ directory)
+set "SCRIPT_DIR=%~dp0"
+:: Remove trailing backslash
+if "%SCRIPT_DIR:~-1%"=="\" set "SCRIPT_DIR=%SCRIPT_DIR:~0,-1%"
+set "PKG_ROOT=%SCRIPT_DIR%\.."
+set "ENTRY=%PKG_ROOT%\src\nimbus.ts"
+
+:: Primary: Node.js >= 18 with tsx ESM loader (project is Node.js-native)
+where node >nul 2>&1
+if %errorlevel% equ 0 (
+  set "TSX_ESM=%PKG_ROOT%\node_modules\tsx\dist\esm\index.mjs"
+  if exist "!TSX_ESM!" (
+    node --loader "!TSX_ESM!" "%ENTRY%" %*
+    exit /b %errorlevel%
+  )
+  :: Try global tsx loader
+  for /f "delims=" %%i in ('npm root -g 2^>nul') do set "NPM_GLOBAL=%%i"
+  if defined NPM_GLOBAL (
+    set "TSX_GLOBAL=!NPM_GLOBAL!\tsx\dist\esm\index.mjs"
+    if exist "!TSX_GLOBAL!" (
+      node --loader "!TSX_GLOBAL!" "%ENTRY%" %*
+      exit /b %errorlevel%
+    )
+  )
+  :: Last resort: node --import tsx
+  node --import tsx "%ENTRY%" %*
+  exit /b %errorlevel%
+)
+
+echo Error: Nimbus requires Node.js ^>= 18. >&2
+echo. >&2
+echo Install Node.js: >&2
+echo   https://nodejs.org/ >&2
+exit /b 1

package/bin/nimbus.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+/**
+ * Nimbus CLI — cross-platform ESM launcher.
+ *
+ * This is the `bin` entry used by npm on all platforms (including Windows).
+ * It locates the package root (following symlinks so npm global installs work),
+ * then spawns Node.js with the tsx ESM loader to execute the TypeScript source.
+ *
+ * Why .mjs instead of a shell script?
+ *   On Windows, npm's cmd-shim cannot wrap a POSIX sh script. A Node.js ESM
+ *   bin entry (#!/usr/bin/env node + .mjs) works on all platforms.
+ */
+
+import { spawnSync, execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
+
+// L1: Enable ANSI color support on Windows terminals (Windows 10+ supports VT100).
+// FORCE_COLOR=1 is the standard signal for chalk/ink/supports-color to emit ANSI codes.
+// This must run before any child process is spawned so the env var is inherited.
+if (process.platform === 'win32') {
+  process.env.FORCE_COLOR ??= '1';
+}
+
+// Resolve the true package root, following symlinks (npm global installs symlink on POSIX).
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PKG_ROOT = resolve(__dirname, '..');
+const ENTRY = join(PKG_ROOT, 'src', 'nimbus.ts');
+
+const passArgs = process.argv.slice(2);
+
+function run(nodeArgs) {
+  const result = spawnSync(process.execPath, [...nodeArgs, ENTRY, ...passArgs], {
+    stdio: 'inherit',
+    env: process.env,
+  });
+  process.exit(result.status ?? (result.error ? 1 : 0));
+}
+
+// 0. Pre-compiled dist (fastest — no tsx overhead)
+const DIST_ENTRY = join(PKG_ROOT, 'dist', 'src', 'nimbus.js');
+if (existsSync(DIST_ENTRY)) {
+  const result = spawnSync(process.execPath, [DIST_ENTRY, ...passArgs], {
+    stdio: 'inherit',
+    env: process.env,
+  });
+  process.exit(result.status ?? (result.error ? 1 : 0));
+}
+
+// 1. tsx ESM loader bundled with this package (most reliable)
+const TSX_BUNDLED = join(PKG_ROOT, 'node_modules', 'tsx', 'dist', 'esm', 'index.mjs');
+if (existsSync(TSX_BUNDLED)) {
+  run(['--loader', TSX_BUNDLED]);
+}
+
+// 2. tsx ESM loader from global npm
+try {
+  const globalRoot = execSync('npm root -g', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  const TSX_GLOBAL = join(globalRoot, 'tsx', 'dist', 'esm', 'index.mjs');
+  if (existsSync(TSX_GLOBAL)) {
+    run(['--loader', TSX_GLOBAL]);
+  }
+} catch {
+  // npm root -g failed — continue
+}
+
+// 3. Last resort: node --import tsx (Node >= 18.19, tsx must be available)
+run(['--import', 'tsx']);

package/completions/nimbus.bash

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+
+# Dynamic completion helpers
+_nimbus_kubectl_contexts() {
+  kubectl config get-contexts -o name 2>/dev/null
+}
+_nimbus_namespaces() {
+  kubectl get namespaces -o name 2>/dev/null | sed 's|namespace/||'
+}
+_nimbus_tf_workspaces() {
+  terraform workspace list 2>/dev/null | sed 's/^[* ]*//'
+}
+
+_nimbus_completions() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  local prev="${COMP_WORDS[COMP_CWORD-1]}"
+  local commands="chat run plan build deploy init login logout help version upgrade update doctor logs status alias pipeline rollback incident runbook schedule export"
+  # G20: Subcommand completions for terraform/kubectl/helm
+  case "${COMP_WORDS[1]}" in
+    tf|terraform) COMPREPLY=($(compgen -W "init plan apply destroy validate workspace output" -- "${cur}")); return ;;
+    k8s|kubectl)  COMPREPLY=($(compgen -W "get apply delete logs scale rollout exec describe diff" -- "${cur}")); return ;;
+    helm)         COMPREPLY=($(compgen -W "install upgrade rollback uninstall list show diff" -- "${cur}")); return ;;
+    runbook)      COMPREPLY=($(compgen -W "list run create" -- "${cur}")); return ;;
+    schedule)     COMPREPLY=($(compgen -W "list add remove run-now" -- "${cur}")); return ;;
+    export)       COMPREPLY=($(compgen -W "--format --output" -- "${cur}")); return ;;
+  esac
+  case "$prev" in
+    --mode) COMPREPLY=($(compgen -W "plan build deploy" -- "$cur")); return ;;
+    --format) COMPREPLY=($(compgen -W "text json table md html" -- "$cur")); return ;;
+    --ui) COMPREPLY=($(compgen -W "ink readline" -- "$cur")); return ;;
+    --context) COMPREPLY=($(compgen -W "$(_nimbus_kubectl_contexts)" -- "$cur")); return ;;
+    --namespace|-n) COMPREPLY=($(compgen -W "$(_nimbus_namespaces)" -- "$cur")); return ;;
+    --workspace) COMPREPLY=($(compgen -W "$(_nimbus_tf_workspaces)" -- "$cur")); return ;;
+    nimbus) COMPREPLY=($(compgen -W "$commands" -- "$cur")); return ;;
+  esac
+  COMPREPLY=($(compgen -W "--mode --format --auto-approve --stdin --model --max-turns --help --version --context --namespace --workspace --quiet --budget" -- "$cur"))
+}
+complete -F _nimbus_completions nimbus

package/completions/nimbus.fish

@@ -0,0 +1,48 @@
+complete -c nimbus -f
+
+# Subcommands
+complete -c nimbus -n '__fish_use_subcommand' -a chat -d 'Interactive DevOps agent TUI'
+complete -c nimbus -n '__fish_use_subcommand' -a run -d 'Run agent non-interactively'
+complete -c nimbus -n '__fish_use_subcommand' -a plan -d 'Preview infrastructure changes'
+complete -c nimbus -n '__fish_use_subcommand' -a init -d 'Generate NIMBUS.md'
+complete -c nimbus -n '__fish_use_subcommand' -a login -d 'Configure LLM provider'
+complete -c nimbus -n '__fish_use_subcommand' -a logout -d 'Remove credentials'
+complete -c nimbus -n '__fish_use_subcommand' -a help -d 'Show help'
+complete -c nimbus -n '__fish_use_subcommand' -a version -d 'Show version'
+complete -c nimbus -n '__fish_use_subcommand' -a upgrade -d 'Upgrade to latest version'
+complete -c nimbus -n '__fish_use_subcommand' -a update -d 'Alias for upgrade'
+complete -c nimbus -n '__fish_use_subcommand' -a doctor -d 'Check environment'
+complete -c nimbus -n '__fish_use_subcommand' -a logs -d 'Stream Kubernetes pod logs'
+complete -c nimbus -n '__fish_use_subcommand' -a status -d 'Show current agent status'
+complete -c nimbus -n '__fish_use_subcommand' -a alias -d 'Manage command aliases'
+complete -c nimbus -n '__fish_use_subcommand' -a pipeline -d 'Run CI/CD pipeline'
+complete -c nimbus -n '__fish_use_subcommand' -a rollback -d 'Rollback infrastructure changes'
+complete -c nimbus -n '__fish_use_subcommand' -a incident -d 'Incident response session'
+complete -c nimbus -n '__fish_use_subcommand' -a runbook -d 'Execute operational runbooks'
+complete -c nimbus -n '__fish_use_subcommand' -a schedule -d 'Manage periodic automation'
+complete -c nimbus -n '__fish_use_subcommand' -a export -d 'Export session to file'
+
+# G20: Subcommand completions for tf/kubectl/helm
+complete -c nimbus -n '__fish_seen_subcommand_from tf terraform' -a 'init plan apply destroy validate workspace output' -d 'terraform subcommand'
+complete -c nimbus -n '__fish_seen_subcommand_from k8s kubectl' -a 'get apply delete logs scale rollout exec describe diff' -d 'kubectl subcommand'
+complete -c nimbus -n '__fish_seen_subcommand_from helm' -a 'install upgrade rollback uninstall list show diff' -d 'helm subcommand'
+complete -c nimbus -n '__fish_seen_subcommand_from runbook' -a 'list run create' -d 'runbook subcommand'
+complete -c nimbus -n '__fish_seen_subcommand_from schedule' -a 'list add remove run-now' -d 'schedule subcommand'
+
+# Flags
+complete -c nimbus -l mode -a 'plan build deploy' -d 'Agent mode'
+complete -c nimbus -l format -a 'text json table md html' -d 'Output format'
+complete -c nimbus -l auto-approve -d 'Auto-approve permissions'
+complete -c nimbus -l model -d 'LLM model override'
+complete -c nimbus -l max-turns -d 'Maximum agent turns'
+complete -c nimbus -l budget -d 'Cost budget in USD'
+complete -c nimbus -l quiet -s q -d 'Suppress banners and decorative headers'
+
+# Dynamic completions for --context (kubectl contexts)
+complete -c nimbus -l context -d 'kubectl context' -a '(kubectl config get-contexts -o name 2>/dev/null)'
+
+# Dynamic completions for --namespace (kubernetes namespaces)
+complete -c nimbus -l namespace -s n -d 'Kubernetes namespace' -a '(kubectl get namespaces -o name 2>/dev/null | string replace "namespace/" "")'
+
+# Dynamic completions for --workspace (terraform workspaces)
+complete -c nimbus -l workspace -d 'Terraform workspace' -a '(terraform workspace list 2>/dev/null | string replace -r "^[* ]*" "")'

package/completions/nimbus.zsh

@@ -0,0 +1,81 @@
+#compdef nimbus
+
+# Dynamic completion helpers
+_nimbus_kubectl_contexts() {
+  local contexts
+  contexts=(${(f)"$(kubectl config get-contexts -o name 2>/dev/null)"})
+  _describe 'kubectl contexts' contexts
+}
+
+_nimbus_namespaces() {
+  local namespaces
+  namespaces=(${(f)"$(kubectl get namespaces -o name 2>/dev/null | sed 's|namespace/||')"})
+  _describe 'kubernetes namespaces' namespaces
+}
+
+_nimbus_tf_workspaces() {
+  local workspaces
+  workspaces=(${(f)"$(terraform workspace list 2>/dev/null | sed 's/^[* ]*//')"})
+  _describe 'terraform workspaces' workspaces
+}
+
+_nimbus() {
+  local -a commands
+  commands=(
+    'chat:Interactive DevOps agent TUI'
+    'run:Run agent non-interactively'
+    'plan:Preview infrastructure changes'
+    'init:Generate NIMBUS.md project context'
+    'login:Configure LLM provider'
+    'logout:Remove credentials'
+    'help:Show help'
+    'version:Show version'
+    'upgrade:Upgrade to latest version'
+    'update:Alias for upgrade'
+    'doctor:Check environment'
+    'logs:Stream Kubernetes pod logs'
+    'status:Show current agent status'
+    'alias:Manage command aliases'
+    'pipeline:Run CI/CD pipeline'
+    'rollback:Rollback infrastructure changes'
+    'incident:Incident response session'
+    'runbook:Execute operational runbooks'
+    'schedule:Manage periodic automation'
+    'export:Export session to file'
+  )
+  _arguments \
+    '1: :->command' \
+    '--mode[Agent mode]:mode:(plan build deploy)' \
+    '--format[Output format]:format:(text json table md html)' \
+    '--auto-approve[Auto-approve permissions]' \
+    '--model[LLM model]:model:' \
+    '--context[kubectl context]:context:_nimbus_kubectl_contexts' \
+    '--namespace[Kubernetes namespace]:namespace:_nimbus_namespaces' \
+    '--workspace[Terraform workspace]:workspace:_nimbus_tf_workspaces' \
+    '--budget[Cost budget in USD]:budget:' \
+    '--quiet[Suppress banners/headers]' \
+    '--version[Show version]' \
+    '--help[Show help]'
+  # G20: Subcommand completions
+  case ${words[2]} in
+    tf|terraform)
+      local -a tf_cmds; tf_cmds=('init' 'plan' 'apply' 'destroy' 'validate' 'workspace' 'output')
+      _describe 'terraform subcommands' tf_cmds; return ;;
+    k8s|kubectl)
+      local -a k8s_cmds; k8s_cmds=('get' 'apply' 'delete' 'logs' 'scale' 'rollout' 'exec' 'describe' 'diff')
+      _describe 'kubectl subcommands' k8s_cmds; return ;;
+    helm)
+      local -a helm_cmds; helm_cmds=('install' 'upgrade' 'rollback' 'uninstall' 'list' 'show' 'diff')
+      _describe 'helm subcommands' helm_cmds; return ;;
+    runbook)
+      local -a rb_cmds; rb_cmds=('list' 'run' 'create')
+      _describe 'runbook subcommands' rb_cmds; return ;;
+    schedule)
+      local -a sched_cmds; sched_cmds=('list' 'add' 'remove' 'run-now')
+      _describe 'schedule subcommands' sched_cmds; return ;;
+  esac
+  case $state in
+    command) _describe 'nimbus commands' commands ;;
+  esac
+}
+_nimbus "$@"