Scripting beyond Bash: When to switch to Python, Go, or Node.js

#!/bin/bash

# Basic log: Always prints to stderr (standard for logs)
log() {
    echo "[$(date +'%Y-%m-%dT%H:%M:%S')] INFO: $1" >&2
}

# Level log: Only prints if VERBOSE is true
logL() {
    if [[ "$VERBOSE" == "true" ]]; then
        echo "[$(date +'%Y-%m-%dT%H:%M:%S')] DEBUG: $1" >&2
    fi
}

parse() {
    local file_path="$1"

    if [[ ! -f "$file_path" ]]; then
        echo "Error: File not found" >&2
        return 1
    fi

    # jq parses the file and ensures it's valid JSON
    # We use '.' to simply validate and output the raw JSON
    messages=$(jq -c '.' "$file_path" 2>/dev/null)
    
    if [[ $? -ne 0 ]]; then
        echo "Error: Invalid JSON" >&2
        return 1
    fi

    echo "$messages"
}

function main() {
    # Default values
    NAME="World"
    FILE_PATH="data.json"
    VERBOSE="false"

    # Argument Parsing
    # n: means -n expects an argument, v has no colon so it's a boolean flag
    while getopts "n:f:v" opt; do
        case $opt in
            n) NAME="$OPTARG" ;;
            f) FILE_PATH="$OPTARG" ;;
            v) VERBOSE="true" ;;
            *) echo "Usage: $0 [-n name] [-f file_path] [-v]" >&2; exit 1 ;;
        esac
    done

    # Execution logic
    logL "Initializing script with NAME=$NAME"
    log "Hello, $NAME!"

    msgs=$(parse "$FILE_PATH")
    if [[ $? -ne 0 ]]; then
        log "Failed to parse JSON file."
        exit 1
    fi
}

# Execute main with all passed arguments
main "$@"

# /// script
# dependencies = ["argparse", "logging", "json"]
# ///
import argparse
import logging
import json

def parse(file_path):
    try:
        with open(file_path, 'r') as file:
            # json.load handles the file stream directly
            messages = json.load(file)
            return messages
    except (FileNotFoundError, json.JSONDecodeError) as e:
        print(f"Error: {e}")
        return None

# 1. Argument Parsing
parser = argparse.ArgumentParser()
parser.add_argument("-n", "--name", default="World", help="The name to greet")
parser.add_argument("-v", "--verbose", action="store_true", help="Enable debug logs")
parser.add_argument("-f", "--file", default="test.json", help="Path to the JSON file to parse")
args = parser.parse_args()

# 2. Logging Setup
log_level = logging.DEBUG if args.verbose else logging.INFO
logging.basicConfig(level=log_level, format="%(asctime)s %(levelname)s: %(message)s")

# 3. Execution
logging.debug(f"Script started with name: {args.name}")
logging.info(f"Hello {args.name}")

messages = parse(args.file)
if messages is not None:
    logging.info(f"Parsed messages: {messages}")

uv run example.py

go version
go version go1.25.5 darwin/arm64

/// 2>/dev/null; exec go run "$0" "$@"

package main

import (
	"encoding/json"
	"flag"
	"log/slog"
	"os"
)

// you can use tools such as https://transform.tools/json-to-go
type Message struct {
	Role    string `json:"role"`
	Content string `json:"content"`
	Date    string `json:"date"`
}

func Parse(filePath string) ([]Message, error) {
	file, err := os.Open(filePath)
	if err != nil {
		return nil, err
	}
	defer file.Close()
	jsonParser := json.NewDecoder(file)
	var messages []Message
	if err := jsonParser.Decode(&messages); err != nil {
		return nil, err
	}
	return messages, nil
}

func main() {
	// 1. Argument Parsing
	name := flag.String("name", "World", "The name to greet")
	verbose := flag.Bool("verbose", false, "Enable debug logs")
	file := flag.String("file", "test.json", "Path to the JSON file")
	flag.Parse()

	// 2. Logging Setup
	level := slog.LevelInfo
	if *verbose {
		level = slog.LevelDebug
	}
	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: level}))

	// 3. Execution
	logger.Debug("Script started", "name", *name)
	logger.Info("Greeting sent", "output", "Hello "+*name)

	messages, err := Parse(*file)
	if err != nil {
		logger.Error("Failed to parse messages", "error", err)
		return
	}
	for idx, msg := range messages {
		logger.Info("Parsed message", "index", idx, "role", msg.Role, "content", msg.Content, "date", msg.Date)
	}
}

# 1: with go run 
go run example.go -name Test -file test.json -verbose

# 2 or via shebang: 
bash example.go -name Test -file test.json -verbose

go mod init example.test

[
    {
        "role": "user",
        "content": "Hello, how are you?",
        "date": "2024-06-15T10:00:00Z"
    }
]

package main

import "testing"

func TestParse(t *testing.T) {
	filePath := "test.json"
	messages, err := Parse(filePath)
	if err != nil {
		t.Fatalf("Expected no error, got %v", err)
	}
	if len(messages) != 1 {
		t.Fatalf("Expected 1 message, got %d", len(messages))
	}
	expectedContent := "Hello, how are you?"
	if messages[0].Content != expectedContent {
		t.Errorf("Expected content %q, got %q", expectedContent, messages[0].Content)
	}
}

#!/usr/bin/env node

import { parseArgs } from 'node:util';
import { readFile } from 'node:fs/promises';

async function parse(filePath) {
    try {
        const data = await readFile(filePath, 'utf8');
        // JSON.parse converts the string into a JavaScript Array/Object
        const messages = JSON.parse(data);
        return messages;
    } catch (err) {
        console.error(`Error: ${err.message}`);
        throw err;
    }
}

async function main() {
    // 1. Argument Parsing
    const options = {
        name: { type: 'string', short: 'n', default: 'World' },
        verbose: { type: 'boolean', short: 'v' }
    };
    const { values } = parseArgs({ options });

    // 2. Logging Logic
    const log = (level, msg, meta = {}) => {
    if (level === 'DEBUG' && !values.verbose) return;
        const timestamp = new Date().toISOString();
        console.log(`[${timestamp}] ${level}: ${msg}`, Object.keys(meta).length ? meta : "");
    };

    // 3. Execution
    log('DEBUG', 'Script started', { name: values.name });
    log('INFO', `Hello ${values.name}`);

    const messages = await parse('tmp/test.json');
    if (messages) {
        log('INFO', `Parsed messages: ${JSON.stringify(messages)}`);
    }
}

main().catch(err => {
  console.error(`Error: ${err.message}`);
  process.exit(1);
});

#!/usr/bin/env zx

// zx provides 'fs' and 'path' globally.
// It also provides 'chalk' for colored output and 'argv' for argument parsing.

async function parse(filePath) {
  // 1. Check if file exists using zx's global fs
  if (!await fs.pathExists(filePath)) {
    throw new Error(`File not found: ${filePath}`);
  }

  // 2. Read and Parse JSON
  // zx includes 'fs-extra' methods like readJson
  try {
    const messages = await fs.readJson(filePath);
    return messages;
  } catch (err) {
    throw new Error(`Failed to parse JSON: ${err.message}`);
  }
}

async function main() {
  // zx parses flags into the 'argv' object automatically
  // Example: node script.mjs --file=data.json --verbose
  const filePath = argv.file || 'data.json';
  const isVerbose = argv.verbose || false;

  // Logging with colors (using global chalk)
  if (isVerbose) console.log(chalk.blue(`[DEBUG] Opening ${filePath}...`));

  try {
    const messages = await parse(filePath);
    
    console.log(chalk.green(`Successfully parsed ${messages.length} messages:`));
    
    messages.forEach(msg => {
      console.log(`${chalk.yellow(`[${msg.role}]`)} (${msg.date}): ${msg.content}`);
    });

  } catch (err) {
    console.error(chalk.red(err.message));
    process.exit(1);
  }
}

await main();

zx example.mjs --file test.json --verbose

#!/usr/bin/env zx

await $`cat package.json | grep name`

const branch = await $`git branch --show-current`
await $`dep deploy --branch=${branch}`

await Promise.all([
  $`sleep 1; echo 1`,
  $`sleep 2; echo 2`,
  $`sleep 3; echo 3`,
])

const name = 'foo bar'
await $`mkdir /tmp/${name}`