Ask HN: Any tool for managing large and variable command lines?

I started using just [0] on my projects and have been very happy so far. It is very similar to make but focused on commands rather than build outputs.

Define your recipes and then you can compose them as needed.

[0] https://github.com/casey/just

I rely on an unlimited bash history and fzf to fuzzy search through it. Commands that get too long and complicated might get thrown into a simple bash script, often quite literally "thrown" as a single line without any cleanup or extra logic.

I've tried making pretty scripts with many options, but as you said, then you just end up with another tool with many complicated options, not to mention the time it takes. I noticed that the quick and dirty scripts that I often just copy paste and tweak if I want to get a different functionality get by far the most use and survive the longest.

I've also been meaning to have a look at invoke[1] which seemed interesting, but I haven't gotten to it yet.

[1] https://www.pyinvoke.org/

If you're using bash, you can edit long commands by hitting C-x C-e. This will open an editor with the command in the buffer. When you save and exit, bash will execute the edited command.

This is not in the style of `transient` in Emacs but it could work well, especially with your wrapper script that takes command line flags.

I use vi-mode and when i need to make more elaborate edits, I have this binding in zsh to edit the current line in $EDITOR:

  autoload -Uz edit-command-line
  zle -N edit-command-line
  bindkey -M vicmd v edit-command-line

  bindkey '^x^e' edit-command-line

But, in truth, the shell interface could use a major overhaul to make it more like a notebook, there are early attempts at this (e.g. Warp), but it's still quite timid IMO.

I'll also say this is one of the perks of being a vi user, it's the CLI usage where it really shines, I can make surgical edits really quickly, thanks to all the jump and change keybinds that are so central to vi usage.

I have a `run` bash file where I just return exit 0 on third line. Then I can copy/paste anything I need up from below the exit 0.

Silly, yes. but it's super easy and extremely fast.

I create wrapper scripts. I try to keep them simple... they're convenience scripts, not a replacement for a build system.

Here's one for a QEMU dev env where I add and remove bits of command line in a freeform way. I just break out the command line into components, and uncomment the ones I want for a particular use:

  #!/bin/bash
  
  set -ex
  
  # Drive created with:
  # /usr/bin/qemu-img create -f qcow2  ngx.qcow2 40G
  
  #vga='-vga cirrus'
  vga='-vga std'
  #vga='-vga qxl'
  
  drive='-drive file=ngx.qcow2,cache=writeback'
  
  tablet='-usbdevice tablet'
  
  #vnc='-vnc :3'
  
  #cdrom="-cdrom base_install.iso"
  #cdrom='-cdrom documentation.iso'
  #cdrom="-cdrom /dev/sr0"
  cdrom=''
  
  #net='-net user -net nic'
  net='-net user,restrict=off,hostfwd=tcp::6666-:6666 -net nic,model=rtl8139,macaddr=00:11:82:C3:54:55'
  #net='-net user,restrict=on,hostfwd=tcp::6666-:6666,hostfwd=tcp::3389-:3389,hostfwd=udp::3389-:3389 -net nic,model=rtl8139,macaddr=00:11:82:C3:54:55'
  
  monitor='-monitor stdio'
  
  qemu-system-x86_64 -enable-kvm -nodefaults -m 768 $vga $drive $tablet $vnc $cdrom $net $monitor

Navi[1] is perfect for this! It's both a fuzzy finder of a personal collection of commands, but it's template syntax is flexible enough to be able to have "command builders"

I have a blog on doing exactly this for a subset of strace[2].

1: https://github.com/denisidoro/navi

2: https://kbknapp.dev/strace-navi/

    history | sed 's/^ *[0-9]* *//' > commands.sh

    vi commands.sh

    (edit the file to only include your big nasty command lines, then comment them all out)

    chmod +x commands.sh

I'm going to recreate something I did a while back, which was to create a vim command/script which would: copy the current selection or line to a specified term window, and hit enter. And then version two, do that, but then copy the contents of the line/selection into a new line.

Basically using vim as an input buffer. With the option to copy the current line- when working systems there was often incremental improvement that I was trying to do, so running then creating a new line was valuable. I probably should just learn how to insert a line offset into the current line though.

What's still missing in both my vim-driven world and in shells is any ability to make references & changes. Ideally I'd like to be able to have lines that interpolate vim registers & more complex expressions. Ideally I want a shell that lets me see my previous raw uninterpolated expressions, that hps me distil out pieces for reuse. The way that history just shows the interpolated version destroys the ability to see what & where I'm borrowing bits of the past that I could be using as hints to re-compose new futures.

For that specific example, I might think about a script which asks interactive questions.

  Do you want to do the kernel build? [Y/n] _

  Which diskfile to use: /path/to/diskfile_    # pre-stuffed editable input

I have removed limit for bash history lines and file size and am using https://github.com/junegunn/fzf for reverse-search, and of course I use ctrl+x ctrl+e to edit long command lines in vim (I have export EDITOR=vim in bashrc)

I am a simpleton, me using CLI is basic compared to what you've described, but I have a tool called Warp on my Mac which helps me with saving terminal commands and making notes on what/why they do stuff. It's free and it's cool imo.

I created a tool I called parseArger to create/maintain bash scripts arguments/options/flags parsing code https://github.com/DimitriGilbert/parseArger It's heavily inspired by ArgBash (https://argbash.dev/) and uses parts of bashly (https://github.com/DannyBen/bashly/) which are very similar tools :) I hope that helps and please forgive the shameless plug...

I made something called shell workspaces[0] for this.

I like to tinker with bash and this has helped me keep all of the commands relevant to a particular project discoverable, accessible, and documented.

It uses a function "," for command execution. So, for instance, if the workspace file defines a function "build", when you're in the workspace, the command `$ , build` will run it.

It's not the most comprehensive solution to this, but it's probably the bit of shell programming that I use almost every day and has saved me tons of time.

[0] https://github.com/nepthar/ws.sh

I would just have a script with either all the variables on top of the script for you to set, or have it look for them in a configuration file you might change a little every run. That’s just my preference for this sort of thing, though. If I can avoid using external stuff or spending time learning new syntax, and keep it as simple and stupid as possible I try and just do that. Sounds like your solution is simple enough with shell history file keeping a record for you. Maybe playing with aliases or writing functions in your bashrc could save some typing for you

Sounds like you want `just` (pretty much a riff on make, but more designed for this use case). I don't find much use for it personally, but I think it fits what you're looking for.

A collection of Jupyter notebooks with "!" calls to binaries. The python requirement is inconvenient but the consistency, output tracking and variables make it worth while.

Which shell? If you’re using bash, you’re missing out - so I’d first upgrade to zsh or fish, which have better options.

The other thing I’d do is get really really good at writing shell scripts. Also nowadays it’s super easy to take an existing complex one liner and ask GPT to make it a robust script with args (but check it of course!)

I also like some of the other suggestions if you’re predisposed to them already, like Makefiles, which are simple, flexible, and powerful.

I've recently used a ruby script with a bunch of methods that I can configure with a few yaml files to generate a shell script which I can then run.

Each run generates a timestamped folder with not only the bash script, but also a copy of the configs used to generate it, and all the data that the commands in the bash script needs (json files). I find this style of generator a common pattern for commonly used but frequently tweaked scripts.

After about 30 years I'm really good at shell. But I don't think it's the best for managing complex workflows.

You could use a local port of something like github actions, but personally I'd pick a language (Python, TypeScript, Ruby) and make a function that takes an input kernel and optional disk and networking config, builds if the tree has changed, and returns the ssh command to the created VM.

If you're comfortable with Python, Invoke [0] can be a great help. You can include your bash code directly inside it, or collect your scripts in a directory and run them from Invoke tasks. Plus, you can easily use all the power of Python on top of your scripts.

[0] https://www.pyinvoke.org/

I've heard good things about atuin

https://github.com/atuinsh/atuin

1. .sh scripts

2. makefiles

3. If you're using bash, try the edit-and-execute-command command. By default, this is assigned to Ctrl-x Ctrl-e (type ctrl-x, then ctrl-e).

I’ve used this https://github.com/secretGeek/ok-bash

It is a menu that works off a file that contains a collection of single line commands.

I like it because it is a local command that is only relevant to the project I’m working on, and sometimes after months of absence it is easy to pick up where I left off.

rather than invoking the script with arguments, you could just define the variables at the top of the script and run it

I would do that via a custom Node application executing commands as child processes driving a container.

If I understand you correctly, this is where I just use a Makefile, but keep it very simple ```render:\tffmtpeg ...``` Do a have dozen of those, and you now have a `make render` command to run that task.

Lately I’ve been running such shell scripts/small commands through org-babel in Emacs. They can be fed one through another which is cool.

Also can recommend Justfile (it has great discoverability and it just works).

Compose all your commands into “does one thing well” and abstract the “thing” it does to an argument… if you have to. Then just chain them together as needed.

I highly recommend Run [0].

[0]: https://github.com/TekWizely/run

Can’t you use aliases or functions in the ~/.bashrc? That’s what I do for complex lines I want to reuse.

Put all the command-line configuration into a shell script with zero arguments.

copy/write edited shell history to unique shell file for each set of edits. make shell file executable. run shell file containing action want to use.

I save stuff into SnippetsLab (macOS only)

A script file?

GUI.

Learn bash. Make a bash file. Make it executable. Put it on your path, or create a ~/bin directory and add that to your path.

You can write whatever crazy nonsense you need.

Snipkit and Pet.

I prefer Pet, mostly because Snipkit makes me verify 20 times (slight exaggerated) and doesn't give me the actual command so it'll be part of the shell history.

Honestly, just dump the command in my shell and let me press enter and make that the confirmation, but whatever.

You can give arguments with default values, so they are reusable across projects.