Terminal Operations

Complete reference for terminal and shell command execution

Terminal Operations

NikCLI provides comprehensive terminal operations for executing shell commands, managing processes, and integrating with development tools. All commands include AI-powered assistance and enhanced output formatting.

Core Terminal Commands

/run [command]

Execute shell commands with enhanced output and AI assistance.

Syntax:

/run <command> [args...]

Features:

• Real-time output streaming
• Exit code handling
• Error analysis and suggestions
• Command history tracking
• Environment variable support

Examples:

# Basic command execution
/run ls -la

# Package management
/run npm install lodash

# Git operations
/run git status

# Build commands
/run npm run build

# System commands
/run ps aux | grep node

# Complex commands with pipes
/run find . -name "*.js" | grep -v node_modules | wc -l

Output Features:

• Syntax highlighting for command output
• Error highlighting and suggestions
• Performance timing
• Resource usage monitoring
• Exit code interpretation

/sh [command]

Execute shell commands (alias for /run).

Syntax:

/sh <command> [args...]

Examples:

# Same functionality as /run
/sh echo "Hello World"
/sh curl -s https://api.github.com/user
/sh docker ps

/bash [command]

Execute commands specifically in bash shell.

Syntax:

/bash <command> [args...]

Features:

• Forces bash shell execution
• Bash-specific features support
• Script execution capabilities

Examples:

# Bash-specific commands
/bash source ~/.bashrc

# Complex bash scripting
/bash 'for i in {1..5}; do echo "Count: $i"; done'

# Bash arrays and functions
/bash 'declare -a arr=("a" "b" "c"); echo ${arr[@]}'

Development Tool Integration

/npm [args]

Execute npm commands with enhanced package management features.

Syntax:

/npm <npm-command> [args...]

Features:

• Package suggestion and analysis
• Dependency conflict detection
• Security vulnerability scanning
• Performance monitoring
• Cache management

Examples:

# Package installation
/npm install react react-dom

# Development dependencies
/npm install --save-dev typescript @types/react

# Global packages
/npm install -g @nicomatt69/nikcli

# Package information
/npm info lodash

# Security audit
/npm audit

# Update packages
/npm update

# Run scripts
/npm run build
/npm run test
/npm run dev

# Package management
/npm list
/npm outdated
/npm prune

Enhanced Features:

• Automatic package suggestions
• Dependency tree analysis
• Bundle size impact analysis
• License compatibility checking

/yarn [args]

Execute Yarn commands with workspace support.

Syntax:

/yarn <yarn-command> [args...]

Features:

• Workspace management
• Plug’n’Play support
• Advanced caching
• Parallel execution

Examples:

# Package installation
/yarn add react react-dom

# Development dependencies
/yarn add --dev typescript

# Workspace commands
/yarn workspace frontend add lodash
/yarn workspaces foreach run build

# Script execution
/yarn build
/yarn test
/yarn dev

# Package management
/yarn info
/yarn upgrade
/yarn dedupe

/git [args]

Execute Git commands with enhanced status and visualization.

Syntax:

/git <git-command> [args...]

Features:

• Enhanced status display
• Branch visualization
• Commit analysis
• Conflict resolution assistance
• Performance optimization

Examples:

# Status and information
/git status
/git log --oneline -10
/git branch -a

# Working with changes
/git add .
/git commit -m "feat: add new feature"
/git push origin main

# Branch management
/git checkout -b feature/new-feature
/git merge develop
/git rebase main

# Remote operations
/git fetch origin
/git pull --rebase
/git push --set-upstream origin feature-branch

# Advanced operations
/git stash
/git cherry-pick abc123
/git reset --hard HEAD~1

Enhanced Output:

• Colorized diff output
• Branch tree visualization
• Commit message analysis
• Merge conflict highlighting

/docker [args]

Execute Docker commands with container management features.

Syntax:

/docker <docker-command> [args...]

Features:

• Container status monitoring
• Image analysis
• Resource usage tracking
• Security scanning
• Multi-platform support

Examples:

# Container management
/docker ps
/docker ps -a
/docker logs container-name
/docker exec -it container-name bash

# Image operations
/docker images
/docker build -t my-app .
/docker pull node:18-alpine
/docker rmi unused-image

# Network and volume management
/docker network ls
/docker volume ls
/docker-compose up -d
/docker-compose down

# System operations
/docker system df
/docker system prune
/docker stats

Enhanced Features:

• Container health monitoring
• Resource usage visualization
• Security vulnerability scanning
• Multi-architecture build support

Process Management

/ps

Show running processes with enhanced information.

Syntax:

/ps [options]

Features:

• Process tree visualization
• Resource usage monitoring
• Port usage detection
• Parent-child relationships

Examples:

# Show all processes
/ps

# Show processes with details
/ps -aux

# Show process tree
/ps --tree

# Show specific processes
/ps node
/ps docker

Output Format:

🔄 Running Processes:

┌─────┬──────────────┬─────────┬─────────┬──────────┬─────────────┐
│ PID │ Name         │ CPU %   │ Memory  │ Port     │ Status      │
├─────┼──────────────┼─────────┼─────────┼──────────┼─────────────┤
│ 1234│ node         │ 15.2%   │ 128MB   │ 3000     │ Running     │
│ 5678│ docker       │ 5.1%    │ 64MB    │ -        │ Running     │
│ 9012│ nginx        │ 2.3%    │ 32MB    │ 80,443   │ Running     │
└─────┴──────────────┴─────────┴─────────┴──────────┴─────────────┘

/kill [pid]

Terminate processes with safety checks.

Syntax:

/kill <pid> [signal]

Parameters:

• pid - Process ID to terminate
• signal - Signal to send (default: TERM)

Safety Features:

• Process ownership verification
• Critical process protection
• Confirmation for system processes
• Graceful shutdown attempts

Examples:

# Terminate process gracefully
/kill 1234

# Force terminate
/kill 1234 KILL

# Terminate by name
/kill node

# Terminate with confirmation
/kill 1234 --confirm

Project Operations

/install [package]

Intelligent package installation with dependency analysis.

Syntax:

/install <package-name> [options]

Features:

• Package manager detection
• Dependency analysis
• Security scanning
• License checking
• Alternative suggestions

Examples:

# Install with auto-detection
/install lodash

# Install development dependency
/install --dev typescript

# Install specific version
/install react@18.2.0

# Install from GitHub
/install user/repo

# Install globally
/install --global @nicomatt69/nikcli

Smart Features:

• Detects package manager (npm, yarn, pnpm)
• Suggests related packages
• Checks for security vulnerabilities
• Analyzes bundle size impact

/build

Execute project build with optimization and analysis.

Syntax:

/build [options]

Features:

• Build script detection
• Performance monitoring
• Bundle analysis
• Error reporting
• Optimization suggestions

Examples:

# Standard build
/build

# Production build
/build --production

# Build with analysis
/build --analyze

# Build specific target
/build --target web

# Clean build
/build --clean

Build Analysis:

• Bundle size reporting
• Dependency analysis
• Performance metrics
• Optimization suggestions
• Error categorization

/test [args]

Execute tests with enhanced reporting and analysis.

Syntax:

/test [test-pattern] [options]

Features:

• Test framework detection
• Coverage reporting
• Performance analysis
• Failure analysis
• Continuous monitoring

Examples:

# Run all tests
/test

# Run specific test file
/test user.test.js

# Run tests with coverage
/test --coverage

# Run tests in watch mode
/test --watch

# Run tests matching pattern
/test --grep "authentication"

# Run tests with specific reporter
/test --reporter json

Enhanced Reporting:

• Visual test results
• Coverage visualization
• Performance benchmarks
• Failure analysis and suggestions
• Historical comparison

/lint

Execute linting with intelligent error analysis.

Syntax:

/lint [files] [options]

Features:

• Multi-linter support
• Auto-fix capabilities
• Rule explanation
• Performance impact analysis
• Custom rule suggestions

Examples:

# Lint all files
/lint

# Lint specific files
/lint src/**/*.js

# Lint with auto-fix
/lint --fix

# Lint with specific config
/lint --config .eslintrc.custom.js

# Lint and report performance
/lint --perf

Intelligent Features:

• Rule explanation and documentation
• Auto-fix suggestions
• Performance impact analysis
• Code quality metrics

Advanced Terminal Features

Command History

Enhanced command history with search and analysis:

# Show command history
/history

# Search command history
/history search "npm install"

# Execute from history
/history exec 15

# Clear history
/history clear

Environment Management

Manage environment variables and configuration:

# Show environment
/env

# Set environment variable
/env NODE_ENV production

# Load from file
/env --file .env.production

# Show specific variables
/env NODE_ENV PATH

Command Aliases

Create and manage command aliases:

# Create alias
/alias ll "ls -la"

# List aliases
/alias

# Remove alias
/alias --remove ll

Command Completion

Intelligent command completion and suggestions:

# Enable completion
/completion enable

# Get command suggestions
/suggest npm  # Shows: install, run, test, build...

# Get parameter suggestions
/suggest git  # Shows: status, add, commit, push...

Performance Monitoring

Resource Usage

Monitor system resources during command execution:

# Enable resource monitoring
/monitor enable

# Commands show resource usage
/run npm run build
# Output includes: CPU: 45%, Memory: 512MB, Time: 2.3s

Benchmarking

Benchmark command performance:

# Benchmark command
/benchmark "npm run build"

# Compare commands
/benchmark "npm run build" "yarn build"

# Historical benchmarks
/benchmark --history

Security Features

Command Validation

Validate commands for security issues:

# Enable security scanning
/security terminal enable

# Commands are scanned for:
# - Dangerous operations
# - Privilege escalation
# - Network access
# - File system access

Sandboxing

Execute commands in sandboxed environments:

# Enable sandbox mode
/sandbox enable

# Commands run with restricted permissions
/run rm -rf /  # Blocked by sandbox

# Temporary sandbox
/sandbox /run dangerous-command

Integration Examples

CI/CD Pipeline

# Typical CI/CD workflow
/run git pull origin main
/install
/lint
/test --coverage
/build --production
/run docker build -t my-app .
/run docker push registry/my-app

Development Workflow

# Daily development workflow
/git status
/git pull --rebase
/install  # Install any new dependencies
/test --watch &  # Start tests in background
/run npm run dev  # Start development server

Deployment Workflow

# Production deployment
/git checkout main
/git pull origin main
/install --production
/build --production
/test --production
/docker build -t app:latest .
/docker push registry/app:latest
/run kubectl apply -f k8s/

Troubleshooting

Common Issues

Command not found:

# Check PATH
/env PATH

# Find command location
/run which node

# Install missing command
/install --global missing-command

Permission denied:

# Check permissions
/run ls -la /path/to/file

# Fix permissions
/run chmod +x script.sh

# Use sudo (with caution)
/run sudo command

Process hanging:

# Find hanging processes
/ps | grep hanging-process

# Terminate hanging process
/kill process-id

# Force terminate
/kill process-id KILL

Debug Commands

# Show terminal debug info
/debug terminal

# Show command execution logs
/debug commands

# Show environment debug info
/debug env

# Test terminal functionality
/diagnostic terminal

Best Practices

Command Safety

• Always verify commands before execution
• Use --dry-run flags when available
• Backup important data before destructive operations
• Use version control for all changes

Performance

• Use appropriate command options
• Monitor resource usage
• Optimize build and test commands
• Use caching when available

Security

• Validate command sources
• Use sandboxing for untrusted commands
• Avoid running commands as root
• Regularly audit command history

Organization

• Use consistent command patterns
• Document complex command sequences
• Create aliases for frequently used commands
• Maintain clean command history