script-refactorer

Modernizes legacy scripts (bash, Node, Python) by replacing deprecated APIs, adding error handling, converting callbacks to async/await, and improving maintainability. Turns brittle one-off scripts into reliable, documented tools.

Ir a la instalación

Repositorio: curiositech/windags-skills
Última actividad en el origen: 31 de marzo de 2026 a las 04:41
Idioma detectado de SKILL.md: inglés
Estrellas: 10
Forks: 2

Opciones de instalación

De forma predeterminada está seleccionado el prompt que primero revisa el origen. Puedes cambiar a un comando directo o descargar una copia local.

Revisa los archivos de origen

Lee SKILL.md y los archivos complementarios que muestra SkillsMP antes de decidir si quieres instalarlo.

Volver a la búsqueda Volver a la instalación

license	Apache-2.0
name	script-refactorer
description	Modernizes legacy scripts (bash, Node, Python) by replacing deprecated APIs, adding error handling, converting callbacks to async/await, and improving maintainability. Turns brittle one-off scripts into reliable, documented tools.
category	Code Quality & Testing
tags	["refactoring","scripts","modernization","cleanup","maintenance"]
allowed-tools	["Read","Bash(*)","Glob","Grep","Write","Edit"]
pairs-with	[{"skill":"refactoring-surgeon","reason":"General refactoring principles applied to scripts"},{"skill":"error-handling-patterns","reason":"Robust error handling is the primary script improvement"},{"skill":"beautiful-cli-design","reason":"Good CLI ergonomics for script interfaces"},{"skill":"devops-automator","reason":"Scripts often live inside CI/CD pipelines"}]

Script Refactorer

Modernizes legacy scripts into reliable, maintainable tools. Replaces deprecated patterns, adds error handling and input validation, converts callback spaghetti to async/await, and turns undocumented one-off hacks into proper CLI tools.

Activation Triggers

Use this skill when:

A bash/Node/Python script works but is fragile, undocumented, or hard to modify
Scripts use deprecated Node.js APIs (e.g., new Buffer(), url.parse(), fs.exists())
Callback-heavy Node.js code needs async/await conversion
Scripts lack error handling and fail silently or with cryptic messages
A script needs proper CLI argument parsing, help text, and exit codes
Legacy Python 2 patterns need updating to modern Python 3
Shell scripts lack set -euo pipefail and proper quoting

Do NOT use this skill for:

Rewriting scripts from scratch in a different language (use the appropriate language skill)
Building new CLI tools (use beautiful-cli-design)
Large application refactoring (use refactor-architect for planning, refactoring-surgeon for execution)
Performance optimization of scripts (use performance-profiling)

Core Capabilities

1. Bash Script Modernization

Before -- the kind of script that makes you wince:

#!/bin/bash
# deploy.sh - "works on my machine"

cd /opt/app
git pull
npm install
npm run build
pm2 restart app
echo "done"

After -- a script you can trust:

#!/usr/bin/env bash
set -euo pipefail

# deploy.sh — Deploy application with rollback safety
# Usage: deploy.sh [--branch <branch>] [--skip-build] [--dry-run]

readonly SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
readonly APP_DIR=
 LOG_FILE=


BRANCH=
SKIP_BUILD=
DRY_RUN=

() {
   <<
   0
}

() {   |  -a ; }
() {   >&2;  1; }

() {
   [[  -gt 0 ]]; 
      
      --branch)   BRANCH=;  2 ;;
      --skip-build) SKIP_BUILD=;  ;;
      --dry-run)  DRY_RUN=;  ;;
      -h|--)  usage ;;
      *)          die  ;;
    
  
}

() {
   -v git >/dev/null 2>&1 || die 
   -v npm >/dev/null 2>&1 || die 
   -v pm2 >/dev/null 2>&1 || die 
  [[ -d  ]] || die 
}

() {
  parse_args 
  preflight_checks

   prev_commit
  prev_commit=$(git -C  rev-parse HEAD)
   
   

   ; 
     
     0
  

  
    ERR

  git -C  fetch origin 
  git -C  checkout 
  git -C  pull origin 

   ! ; 
     
    (  && npm ci --production)
     
    (  && npm run build)
  

   
  pm2 restart 

   
}

main

Deprecated	Replacement	Since
`new Buffer(data)`	`Buffer.from(data)`	Node 6
`Buffer(size)`	`Buffer.alloc(size)`	Node 6
`url.parse(str)`	`new URL(str)`	Node 10
`url.resolve(from, to)`	`new URL(to, from).href`	Node 10
`fs.exists(path, cb)`	`fs.access(path)` or `fs.stat(path)`	Node 1
`path.exists()`	`fs.existsSync()`	Node 1
`require('domain')`	`AsyncLocalStorage`	Node 13
`crypto.createCipher()`	`crypto.createCipheriv()`	Node 10
`process.binding()`	N/A (internal only)	Node 10
`util.puts/print/debug`	`console.log/error`	Node 0.12
`sys` module	`util` module	Ancient
`querystring.parse()`	`URLSearchParams`	Node 10
`os.tmpDir()`	`os.tmpdir()`	Node 4

const fs = require('fs');
const path = require('path');

function processFiles(dir, callback) {
  fs.readdir(dir, function(err, files) {
    if (err) return callback(err);
    let results = [];
    let pending = files.length;
    if (!pending) return callback(null, results);
    files.forEach(function(file) {
      const filePath = path.join(dir, file);
      fs.stat(filePath, function(err, stat) {
        if (err) return callback(err);
        if (stat.isDirectory()) {
          processFiles(filePath, function(err, res) {
            if (err) return callback(err);
            results = results.concat(res);
            if (!--pending) callback(null, results);
          });
        } else {
          fs.readFile(filePath, 'utf8', function(err, content) {
            if (err) return callback(err);
            results.push({ path: filePath, content: content });
            if (!--pending) callback(null, results);
          });
        }
      });
    });
  });
}

import { readdir, stat, readFile } from 'node:fs/promises';
import { join } from 'node:path';

async function processFiles(dir) {
  const entries = await readdir(dir, { withFileTypes: true });
  const results = await Promise.all(
    entries.map(async (entry) => {
      const filePath = join(dir, entry.name);
      if (entry.isDirectory()) {
        return processFiles(filePath);
      }
      const content = await readFile(filePath, 'utf8');
      return [{ path: filePath, content }];
    })
  );
  return results.flat();
}

# BEFORE: Python 2/early 3 patterns
import os
import sys
import json

# String formatting
msg = "Hello %s, you have %d items" % (name, count)

# File handling
f = open('data.json', 'r')
data = json.load(f)
f.close()

# Path construction
config_path = os.path.join(os.path.dirname(__file__), '..', 'config', 'settings.json')

# Subprocess
import subprocess
output = subprocess.Popen(['ls', '-la'], stdout=subprocess.PIPE).communicate()[0]

# Type checking
if type(x) == str:
    pass

# AFTER: Modern Python 3.10+
from pathlib import Path
import json
import subprocess
import sys

# f-strings
msg = f"Hello {name}, you have {count} items"

# Context manager
with Path('data.json').open() as f:
    data = json.load(f)

# pathlib
config_path = Path(__file__).parent.parent / 'config' / 'settings.json'

# subprocess.run
result = subprocess.run(['ls', '-la'], capture_output=True, text=True, check=True)
output = result.stdout

# isinstance
if isinstance(x, str):
    pass

# Bash: proper signal handling
cleanup() {
  log "Caught signal, cleaning up..."
  rm -f "$LOCK_FILE"
  exit 130  # 128 + SIGINT(2)
}
trap cleanup INT TERM

# Exit code conventions
# 0 = success
# 1 = general error
# 2 = misuse of shell command (bad args)
# 126 = command not executable
# 127 = command not found
# 130 = terminated by Ctrl+C (128+2)
# 143 = terminated by SIGTERM (128+15)

// Node.js: graceful shutdown
process.on('SIGINT', async () => {
  console.log('\nReceived SIGINT. Cleaning up...');
  await cleanup();
  process.exit(130);
});

process.on('SIGTERM', async () => {
  console.log('Received SIGTERM. Shutting down gracefully...');
  await cleanup();
  process.exit(143);
});

process.on('uncaughtException', (err) => {
  console.error('Uncaught exception:', err.message);
  process.exit(1);
});

process.on('unhandledRejection', (reason) => {
  console.error('Unhandled rejection:', reason);
  process.exit(1);
});

Signal	Action
Script is < 100 lines and basically works	Refactor in place
Script works but has no error handling	Add error handling, keep logic
Script uses APIs deprecated 2+ major versions ago	Replace deprecated APIs
Script is > 300 lines with tangled control flow	Consider splitting into modules first
Script is in a dead language/runtime	Rewrite (but that's a different skill)
Script is a critical production tool	Refactor incrementally with tests

Language	Recommended	Why
Bash	Manual `case` loop or `getopts`	No dependencies, portable
Node.js	`parseArgs` (built-in since Node 18.3)	Zero dependencies
Python	`argparse` (stdlib)	Battle-tested, auto-generates help
Go	`flag` (stdlib) or `cobra`	Standard practice