{
  "sysadminAITasks": {
    "scriptGeneration": {
      "logAnalysis": "automated-log-parsing-scripts",
      "monitoringSetup": "system-monitoring-configuration",
      "backupAutomation": "backup-and-recovery-scripts",
      "userManagement": "bulk-user-administration"
    },
    "configurationManagement": {
      "ansiblePlaybooks": "infrastructure-as-code-generation",
      "dockerContainers": "containerization-scripts",
      "kubernetesManifests": "k8s-deployment-configuration",
      "terraformModules": "cloud-infrastructure-provisioning"
    },
    "troubleshooting": {
      "diagnosticScripts": "system-health-check-automation",
      "performanceAnalysis": "resource-utilization-scripts",
      "networkTroubleshooting": "connectivity-testing-tools",
      "securityAuditing": "security-compliance-checking"
    }
  }
}

{
  "securityFramework": {
    "inputValidation": {
      "sanitization": "strict-input-sanitization",
      "validation": "parameter-type-checking",
      "authentication": "privilege-verification"
    },
    "privilegeManagement": {
      "leastPrivilege": "minimal-required-permissions",
      "sudoUsage": "controlled-elevated-access",
      "userContext": "appropriate-user-execution"
    },
    "auditTrail": {
      "logging": "comprehensive-action-logging",
      "monitoring": "script-execution-monitoring",
      "alerting": "anomaly-detection"
    }
  }
}

{
  "toolSelectionCriteria": {
    "technicalCapabilities": {
      "infrastructureKnowledge": "understanding-of-sysadmin-contexts",
      "crossPlatformSupport": "windows-linux-macos-compatibility",
      "cloudProviderIntegration": "aws-azure-gcp-support",
      "configurationManagement": "ansible-terraform-puppet-support"
    },
    "operationalRequirements": {
      "securityCompliance": "enterprise-security-standards",
      "auditability": "change-tracking-and-logging",
      "reliability": "minimal-downtime-risk",
      "supportQuality": "enterprise-support-availability"
    },
    "costConsiderations": {
      "scalingCosts": "cost-per-additional-user",
      "apiUsage": "cost-per-automation-execution",
      "infrastructureOverhead": "additional-infrastructure-requirements"
    }
  }
}

{
  "scriptGenerationWorkflow": {
    "requirements": {
      "taskDefinition": "clear-script-requirements",
      "environmentContext": "target-system-specifications",
      "securityConstraints": "security-and-compliance-requirements",
      "errorHandling": "failure-scenario-planning"
    },
    "generation": {
      "aiPrompting": "structured-script-generation-prompts",
      "templateUsage": "organization-standard-templates",
      "bestPractices": "security-and-maintainability-patterns",
      "testing": "automated-script-validation"
    }
  }
}

Generate a bash script for automated log rotation with the following requirements:
- Rotate logs in /var/log/applications/
- Keep 30 days of compressed logs
- Send email notification on errors
- Run as non-root user with appropriate permissions
- Include comprehensive error handling
- Follow security best practices for file operations

#!/bin/bash
# AI-Generated Log Rotation Script
# Generated: $(date)
# Requirements: Log rotation with 30-day retention

set -euo pipefail  # Exit on error, undefined variables, pipe failures

# Configuration
LOG_DIR="/var/log/applications"
RETENTION_DAYS=30
NOTIFICATION_EMAIL="admin@company.com"
SCRIPT_USER="logrotate"

# Input validation and security checks
[Additional security and validation code...]

# AI-Generated Windows Service Management Script
# Includes error handling, logging, and security validation

[CmdletBinding()]
param(
    [Parameter(Mandatory=$true)]
    [string]$ServiceName,

    [Parameter(Mandatory=$true)]
    [ValidateSet("Start","Stop","Restart","Status")]
    [string]$Action
)

# Security validation and privilege checking
if (-NOT ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator")) {
    Write-Error "This script requires administrator privileges."
    exit 1
}

{
  "iacGeneration": {
    "ansiblePlaybooks": {
      "taskDefinition": "infrastructure-requirements-analysis",
      "playbookGeneration": "role-based-playbook-creation",
      "variableManagement": "environment-specific-variables",
      "securityHardening": "security-baseline-implementation"
    },
    "terraformModules": {
      "resourceDefinition": "cloud-resource-specification",
      "moduleStructure": "reusable-module-creation",
      "stateManagement": "terraform-state-configuration",
      "providerOptimization": "multi-cloud-compatibility"
    }
  }
}

Create an Ansible playbook that:
- Installs and configures Nginx on a current Ubuntu LTS server
- Sets up SSL certificates using Let's Encrypt
- Configures firewall rules for web traffic
- Implements security hardening (disable server tokens, etc.)
- Includes proper error handling and idempotency
- Follows Ansible best practices for role organization

---
# AI-Generated Nginx Installation and Configuration Playbook
- name: Install and configure Nginx with SSL
  hosts: webservers
  become: yes
  vars:
    nginx_user: www-data
    ssl_email: admin@company.com

  tasks:
    - name: Update apt cache
      apt:
        update_cache: yes
        cache_valid_time: 3600
      tags: [setup]

    - name: Install Nginx
      apt:
        name: nginx
        state: present
      notify: restart nginx
      tags: [nginx]

# AI-Generated Terraform Module for AWS Web Application Infrastructure
# Includes VPC, security groups, load balancer, and auto-scaling

terraform {
  required_version = ">= 1.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

variable "environment" {
  description = "Environment name (dev, staging, prod)"
  type        = string
  validation {
    condition     = can(regex("^(dev|staging|prod)$", var.environment))
    error_message = "Environment must be dev, staging, or prod."
  }
}

# VPC Configuration
resource "aws_vpc" "main" {
  cidr_block           = var.vpc_cidr
  enable_dns_hostnames = true
  enable_dns_support   = true

  tags = {
    Name        = "${var.environment}-vpc"
    Environment = var.environment
    ManagedBy   = "terraform"
  }
}

{
  "monitoringAutomation": {
    "systemMetrics": {
      "cpuMonitoring": "cpu-utilization-tracking",
      "memoryMonitoring": "memory-usage-analysis",
      "diskMonitoring": "disk-space-and-io-monitoring",
      "networkMonitoring": "network-traffic-analysis"
    },
    "applicationMonitoring": {
      "serviceHealth": "service-availability-checking",
      "performanceMetrics": "application-performance-monitoring",
      "logAnalysis": "error-pattern-detection",
      "dependencyTracking": "service-dependency-monitoring"
    },
    "alerting": {
      "thresholdAlerts": "configurable-threshold-based-alerts",
      "anomalyDetection": "statistical-anomaly-detection",
      "escalationPaths": "tiered-alert-escalation",
      "notificationChannels": "multi-channel-notifications"
    }
  }
}

#!/usr/bin/env python3
# AI-Generated System Monitoring Script
# Monitors CPU, memory, disk, and network metrics
# Sends alerts via email and Slack when thresholds are exceeded

import psutil
import json
import smtplib
import requests
from datetime import datetime
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

class SystemMonitor:
    def __init__(self, config_file="monitor_config.json"):
        with open(config_file, 'r') as f:
            self.config = json.load(f)

        self.thresholds = self.config['thresholds']
        self.notifications = self.config['notifications']

    def check_cpu_usage(self):
        """Monitor CPU usage and trigger alerts if threshold exceeded"""
        cpu_percent = psutil.cpu_percent(interval=1)

        if cpu_percent > self.thresholds['cpu']['critical']:
            self.send_alert(
                severity="CRITICAL",
                message=f"CPU usage is {cpu_percent}% (threshold: {self.thresholds['cpu']['critical']}%)",
                metric="cpu"
            )
        elif cpu_percent > self.thresholds['cpu']['warning']:
            self.send_alert(
                severity="WARNING", 
                message=f"CPU usage is {cpu_percent}% (threshold: {self.thresholds['cpu']['warning']}%)",
                metric="cpu"
            )

        return cpu_percent

    def send_alert(self, severity, message, metric):
        """Send alert via configured notification channels"""
        alert_data = {
            'timestamp': datetime.now().isoformat(),
            'severity': severity,
            'message': message,
            'metric': metric,
            'hostname': self.config['hostname']
        }

        if self.notifications['email']['enabled']:
            self._send_email_alert(alert_data)

        if self.notifications['slack']['enabled']:
            self._send_slack_alert(alert_data)

{
  "terraformAIWorkflow": {
    "planning": {
      "requirementAnalysis": "infrastructure-requirements-gathering",
      "resourceMapping": "aws-azure-gcp-resource-identification",
      "dependencyAnalysis": "resource-dependency-mapping",
      "costEstimation": "infrastructure-cost-projection"
    },
    "generation": {
      "moduleCreation": "reusable-terraform-modules",
      "variableDefinition": "environment-specific-variables",
      "outputGeneration": "resource-output-configuration",
      "validation": "terraform-plan-validation"
    }
  }
}

# AI-Generated Multi-Tier Web Application Infrastructure
# Includes: VPC, ECS Cluster, RDS Database, Load Balancer, Auto Scaling

locals {
  common_tags = {
    Environment   = var.environment
    Project       = var.project_name
    ManagedBy     = "terraform"
  }
}

# Data sources for existing resources
data "aws_availability_zones" "available" {
  state = "available"
}

data "aws_ami" "amazon_linux" {
  most_recent = true
  owners      = ["amazon"]

  filter {
    name   = "name"
    values = ["amzn2-ami-hvm-*-x86_64-gp2"]
  }
}

# VPC and Networking
module "vpc" {
  source = "terraform-aws-modules/vpc/aws"

  name = "${var.project_name}-${var.environment}-vpc"
  cidr = var.vpc_cidr

  azs             = slice(data.aws_availability_zones.available.names, 0, 3)
  private_subnets = var.private_subnets
  public_subnets  = var.public_subnets

  enable_nat_gateway = true
  enable_vpn_gateway = false
  enable_dns_hostnames = true
  enable_dns_support   = true

  tags = local.common_tags
}

# Security Groups
resource "aws_security_group" "web" {
  name        = "${var.project_name}-${var.environment}-web-sg"
  description = "Security group for web servers"
  vpc_id      = module.vpc.vpc_id

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
    description = "HTTP traffic from anywhere"
  }

  ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp" 
    cidr_blocks = ["0.0.0.0/0"]
    description = "HTTPS traffic from anywhere"
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
    description = "All outbound traffic"
  }

  tags = merge(local.common_tags, {
    Name = "${var.project_name}-${var.environment}-web-sg"
  })
}

{
  "containerAutomation": {
    "imageBuildManagement": {
      "dockerfileGeneration": "optimized-dockerfile-creation",
      "buildOptimization": "multi-stage-build-implementation",
      "securityScanning": "container-vulnerability-assessment",
      "registryManagement": "image-registry-automation"
    },
    "deploymentAutomation": {
      "containerOrchestration": "docker-compose-generation",
      "serviceDiscovery": "container-service-configuration",
      "loadBalancing": "container-load-balancer-setup",
      "healthChecking": "container-health-monitoring"
    }
  }
}

# AI-Generated Docker Compose for Multi-Service Application
# Includes: Web Application, Database, Redis Cache, Nginx Proxy

version: '3.8'

services:
  # Web Application Service
  web:
    build:
      context: .
      dockerfile: Dockerfile.web
      args:
        - NODE_ENV=production
    environment:
      - DATABASE_URL=postgresql://app:${DB_PASSWORD}@db:5432/appdb
      - REDIS_URL=redis://redis:6379
      - JWT_SECRET=${JWT_SECRET}
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    restart: unless-stopped
    networks:
      - app-network
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.web.rule=Host(`${DOMAIN_NAME}`)"
      - "traefik.http.services.web.loadbalancer.server.port=3000"

  # PostgreSQL Database
  db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_DB=appdb
      - POSTGRES_USER=app
      - POSTGRES_PASSWORD=${DB_PASSWORD}
    volumes:
      - db_data:/var/lib/postgresql/data
      - ./db/init.sql:/docker-entrypoint-initdb.d/init.sql
    restart: unless-stopped
    networks:
      - app-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app -d appdb"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s

  # Redis Cache
  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes --requirepass ${REDIS_PASSWORD}
    volumes:
      - redis_data:/data
    restart: unless-stopped
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Nginx Reverse Proxy
  nginx:
    image: nginx:alpine
    ports:
      - "80:80" 
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/ssl:/etc/nginx/ssl:ro
    depends_on:
      - web
    restart: unless-stopped
    networks:
      - app-network

volumes:
  db_data:
    driver: local
  redis_data:
    driver: local

networks:
  app-network:
    driver: bridge

# AI-Generated Kubernetes Deployment with Best Practices
# Includes: Deployment, Service, Ingress, ConfigMap, Secret

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
  namespace: production
  labels:
    app: web-app
    version: v1.0.0
    environment: production
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
        version: v1.0.0
    spec:
      serviceAccountName: web-app-service-account
      securityContext:
        runAsNonRoot: true
        runAsUser: 1001
        fsGroup: 1001
      containers:
      - name: web-app
        image: myregistry/web-app:v1.0.0
        imagePullPolicy: IfNotPresent
        ports:
        - name: http
          containerPort: 8080
          protocol: TCP
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: app-secrets
              key: database-url
        - name: REDIS_URL
          valueFrom:
            configMapKeyRef:
              name: app-config
              key: redis-url
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: http
          initialDelaySeconds: 30
          periodSeconds: 10
          timeoutSeconds: 5
          failureThreshold: 3
        readinessProbe:
          httpGet:
            path: /ready
            port: http
          initialDelaySeconds: 5
          periodSeconds: 5
          timeoutSeconds: 3
          failureThreshold: 3
        securityContext:
          allowPrivilegeEscalation: false
          readOnlyRootFilesystem: true
          capabilities:
            drop:
            - ALL

{
  "logAnalysisFramework": {
    "dataIngestion": {
      "logSources": "syslog-application-security-logs",
      "formatParsing": "structured-unstructured-log-parsing",
      "realTimeProcessing": "streaming-log-analysis",
      "historicalAnalysis": "batch-log-processing"
    },
    "patternRecognition": {
      "anomalyDetection": "statistical-anomaly-identification",
      "errorPatterns": "error-signature-recognition",
      "performancePatterns": "performance-trend-analysis",
      "securityPatterns": "security-event-identification"
    }
  }
}

#!/usr/bin/env python3
# AI-Generated Advanced Log Analysis Tool
# Analyzes system logs for patterns, anomalies, and security events

import re
import json
import argparse
from datetime import datetime, timedelta
from collections import defaultdict, Counter
from pathlib import Path
import pandas as pd
from scipy import stats

class LogAnalyzer:
    def __init__(self, config_path="log_config.json"):
        with open(config_path, 'r') as f:
            self.config = json.load(f)

        self.patterns = {
            'failed_login': r'Failed password for .+ from (\d+\.\d+\.\d+\.\d+)',
            'successful_login': r'Accepted password for (.+) from (\d+\.\d+\.\d+\.\d+)',
            'error_pattern': r'ERROR:(.+)',
            'warning_pattern': r'WARNING:(.+)',
            'performance_slow': r'Slow query: (.+) \[(\d+\.?\d*)s\]'
        }

        self.metrics = defaultdict(list)
        self.alerts = []

    def parse_log_file(self, log_file_path):
        """Parse log file and extract relevant information"""
        log_entries = []

        try:
            with open(log_file_path, 'r') as f:
                for line_num, line in enumerate(f, 1):
                    entry = self._parse_log_line(line.strip(), line_num)
                    if entry:
                        log_entries.append(entry)
        except Exception as e:
            print(f"Error reading log file {log_file_path}: {e}")
            return []

        return log_entries

    def detect_anomalies(self, entries, window_minutes=60):
        """Detect statistical anomalies in log patterns"""
        time_windows = defaultdict(list)

        for entry in entries:
            window = entry['timestamp'].replace(
                minute=entry['timestamp'].minute // window_minutes * window_minutes,
                second=0,
                microsecond=0
            )
            time_windows[window].append(entry)

        window_metrics = []
        for window, window_entries in time_windows.items():
            metrics = {
                'window': window,
                'total_entries': len(window_entries),
                'error_count': len([e for e in window_entries if e['severity'] == 'ERROR']),
                'warning_count': len([e for e in window_entries if e['severity'] == 'WARNING']),
                'unique_hosts': len(set(e['hostname'] for e in window_entries))
            }
            window_metrics.append(metrics)

        if len(window_metrics) > 10:
            error_counts = [m['error_count'] for m in window_metrics]
            z_scores = stats.zscore(error_counts)

            for i, (metric, z_score) in enumerate(zip(window_metrics, z_scores)):
                if abs(z_score) > 2:
                    self.alerts.append({
                        'type': 'anomaly',
                        'severity': 'WARNING' if abs(z_score) > 2 else 'INFO',
                        'message': f"Anomalous error count detected: {metric['error_count']} errors (Z-score: {z_score:.2f})",
                        'timestamp': metric['window']
                    })

#!/usr/bin/env python3
# AI-Generated Performance Monitoring Script
# Tracks CPU, memory, disk, network, and application performance

import psutil
import time
import json
import sqlite3
from datetime import datetime
from threading import Thread
import requests

class PerformanceMonitor:
    def __init__(self, config_file="perf_config.json"):
        with open(config_file, 'r') as f:
            self.config = json.load(f)

        self.db_path = self.config.get('database_path', 'performance.db')
        self.monitoring_interval = self.config.get('interval_seconds', 60)
        self.alert_webhooks = self.config.get('alert_webhooks', [])

        self.init_database()
        self.running = False

    def collect_metrics(self):
        """Collect comprehensive system performance metrics"""
        cpu_percent = psutil.cpu_percent(interval=1)
        load_avg = psutil.getloadavg()[0] if hasattr(psutil, 'getloadavg') else 0

        memory = psutil.virtual_memory()
        memory_percent = memory.percent

        disk = psutil.disk_usage('/')
        disk_percent = disk.percent

        network = psutil.net_io_counters()
        network_bytes_sent = network.bytes_sent
        network_bytes_recv = network.bytes_recv

        process_count = len(psutil.pids())

        metrics = {
            'timestamp': datetime.now(),
            'cpu_percent': cpu_percent,
            'memory_percent': memory_percent,
            'disk_usage_percent': disk_percent,
            'network_bytes_sent': network_bytes_sent,
            'network_bytes_recv': network_bytes_recv,
            'load_average': load_avg,
            'process_count': process_count
        }

        return metrics

    def check_thresholds(self, metrics):
        """Check metrics against configured thresholds and generate alerts"""
        thresholds = self.config.get('thresholds', {})
        alerts = []

        cpu_threshold = thresholds.get('cpu_percent', {})
        if metrics['cpu_percent'] > cpu_threshold.get('critical', 90):
            alerts.append({
                'type': 'cpu_usage',
                'severity': 'CRITICAL',
                'message': f"CPU usage critically high: {metrics['cpu_percent']:.1f}%",
                'value': metrics['cpu_percent'],
                'threshold': cpu_threshold['critical']
            })
        elif metrics['cpu_percent'] > cpu_threshold.get('warning', 80):
            alerts.append({
                'type': 'cpu_usage',
                'severity': 'WARNING',
                'message': f"CPU usage high: {metrics['cpu_percent']:.1f}%",
                'value': metrics['cpu_percent'],
                'threshold': cpu_threshold['warning']
            })

        return alerts

{
  "securityAuditFramework": {
    "systemHardening": {
      "userAccountAudit": "check-password-policies-user-permissions",
      "serviceConfiguration": "verify-secure-service-settings",
      "networkSecurity": "firewall-rules-open-ports-analysis",
      "fileSystemSecurity": "permissions-ownership-validation"
    },
    "complianceChecking": {
      "cisCompliance": "center-internet-security-benchmark-validation",
      "pciCompliance": "payment-card-industry-requirements",
      "hipaaCompliance": "healthcare-data-protection-standards",
      "customPolicies": "organization-specific-security-policies"
    }
  }
}

#!/usr/bin/env python3
# AI-Generated Security Audit Script
# Comprehensive system security assessment and compliance checking

import os
import pwd
import grp
import subprocess
import json
from datetime import datetime
from pathlib import Path

class SecurityAuditor:
    def __init__(self, config_file="security_config.json"):
        with open(config_file, 'r') as f:
            self.config = json.load(f)

        self.audit_results = {
            'timestamp': datetime.now().isoformat(),
            'hostname': os.uname().nodename,
            'checks': {},
            'findings': [],
            'compliance_score': 0
        }

    def audit_user_accounts(self):
        """Audit user accounts and password policies"""
        findings = []

        try:
            with open('/etc/shadow', 'r') as f:
                for line in f:
                    parts = line.strip().split(':')
                    username = parts[0]
                    password_hash = parts[1]

                    if password_hash == '' or password_hash == '*':
                        findings.append({
                            'severity': 'HIGH',
                            'type': 'empty_password',
                            'message': f"User {username} has empty or disabled password",
                            'recommendation': "Set strong password or disable account"
                        })
        except PermissionError:
            findings.append({
                'severity': 'MEDIUM',
                'type': 'access_denied',
                'message': "Unable to read /etc/shadow - insufficient privileges",
                'recommendation': "Run audit with appropriate privileges"
            })

        for user in pwd.getpwall():
            if user.pw_uid == 0 and user.pw_name != 'root':
                findings.append({
                    'severity': 'CRITICAL',
                    'type': 'root_privilege',
                    'message': f"User {user.pw_name} has root privileges (UID 0)",
                    'recommendation': "Remove root privileges or justify business need"
                })

        self.audit_results['checks']['user_accounts'] = {
            'status': 'completed',
            'findings_count': len(findings),
            'findings': findings
        }
        self.audit_results['findings'].extend(findings)

    def audit_file_permissions(self):
        """Audit critical file and directory permissions"""
        findings = []

        critical_files = {
            '/etc/passwd': '644',
            '/etc/shadow': '640',
            '/etc/group': '644',
            '/etc/gshadow': '640',
            '/etc/ssh/sshd_config': '600',
            '/etc/sudoers': '440'
        }

        for file_path, expected_perms in critical_files.items():
            if os.path.exists(file_path):
                stat_info = os.stat(file_path)
                actual_perms = oct(stat_info.st_mode)[-3:]

                if actual_perms != expected_perms:
                    findings.append({
                        'severity': 'HIGH',
                        'type': 'file_permissions',
                        'message': f"File {file_path} has permissions {actual_perms}, expected {expected_perms}",
                        'recommendation': f"chmod {expected_perms} {file_path}"
                    })

        self.audit_results['checks']['file_permissions'] = {
            'status': 'completed',
            'findings_count': len(findings),
            'findings': findings
        }
        self.audit_results['findings'].extend(findings)

    def audit_network_security(self):
        """Audit network security configuration"""
        findings = []

        try:
            netstat_result = subprocess.run([
                'ss', '-tuln'
            ], capture_output=True, text=True)

            if netstat_result.returncode == 0:
                dangerous_ports = [23, 21, 135, 139, 445, 1433, 3389]
                lines = netstat_result.stdout.split('\n')

                for line in lines[1:]:
                    if line.strip():
                        parts = line.split()
                        if len(parts) >= 5:
                            local_address = parts[4]
                            if ':' in local_address:
                                port_str = local_address.rsplit(':', 1)[-1]
                                if port_str.isdigit():
                                    port = int(port_str)
                                    if port in dangerous_ports:
                                        findings.append({
                                            'severity': 'HIGH',
                                            'type': 'dangerous_port',
                                            'message': f"Potentially dangerous port {port} is open",
                                            'recommendation': "Close unnecessary ports or restrict access"
                                        })

        except Exception as e:
            findings.append({
                'severity': 'MEDIUM',
                'type': 'audit_error',
                'message': f"Could not check open ports: {str(e)}",
                'recommendation': "Manual port scan verification needed"
            })

        self.audit_results['checks']['network_security'] = {
            'status': 'completed',
            'findings_count': len(findings),
            'findings': findings
        }
        self.audit_results['findings'].extend(findings)

{
  "sysadminCodeReview": {
    "reviewCriteria": {
      "security": {
        "privilegeEscalation": "check-for-unnecessary-sudo-usage",
        "inputValidation": "validate-all-user-inputs",
        "credentialHandling": "secure-credential-management",
        "errorHandling": "prevent-information-disclosure"
      },
      "reliability": {
        "errorHandling": "comprehensive-error-handling",
        "idempotency": "scripts-can-run-multiple-times",
        "logging": "adequate-logging-for-troubleshooting",
        "rollback": "provide-rollback-mechanisms"
      },
      "maintainability": {
        "documentation": "clear-comments-and-documentation",
        "modularity": "reusable-functions-and-modules",
        "standardCompliance": "follow-team-coding-standards",
        "versionControl": "proper-version-control-usage"
      }
    }
  }
}

{
  "testingFramework": {
    "environments": {
      "development": {
        "purpose": "initial-script-development",
        "safety": "isolated-from-production",
        "dataPolicy": "synthetic-data-only"
      },
      "staging": {
        "purpose": "production-like-testing",
        "safety": "production-data-copy",
        "dataPolicy": "anonymized-production-data"
      },
      "production": {
        "purpose": "final-validation",
        "safety": "canary-deployment",
        "dataPolicy": "full-audit-logging"
      }
    }
  }
}

{
  "documentationWorkflow": {
    "scriptDocumentation": {
      "headerComments": "purpose-usage-author-date",
      "functionDocumentation": "parameters-returns-examples",
      "changeLog": "version-history-tracking"
    },
    "knowledgeTransfer": {
      "runbooks": "step-by-step-operational-procedures",
      "troubleshootingGuides": "common-issues-and-solutions",
      "architectureDiagrams": "infrastructure-topology-documentation"
    }
  }
}