17 changed files with 303 additions and 1302 deletions
--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,29 +1,18 @@
 [package]
 name = "remux"
-version = "0.4.0"
+version = "0.1.3"
 edition = "2021"
 authors = [ "Valerie Wolfe <sleeplessval@gmail.com>" ]
 description = "A friendly command shortener for tmux"
-homepage = "https://git.vwolfe.io/valerie/remux"
 repository = "https://git.vwolfe.io/valerie/remux"
 license = "MIT"
-categories = [ "command-line-utilities" ]
-keywords = [ "tmux", "remux" ]

-[package.metadata.aur]
-name = "remux"
-type = "source"
-archive = "archive/v$pkgver.tar.gz"
-depends = [ "tmux>=3.0" ]
-
-[[bin]]
-name = "remux"
-path = "src/main.rs"
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
 pico-args = { version = "0.5.0", features = [ "combined-flags", "eq-separator" ] }
 termion = "2.0.1"
-tmux_interface = "0.3.2"
+tmux_interface = "0.2.1"

 [profile.release]
 opt-level = 's'
--- a/README.md
+++ b/README.md
@ -7,111 +7,37 @@ A tmux wrapper and command shortener written in Rust. ReMux's
 goal is to wrap tmux commands to be both shorter, and oriented
 around session names instead of session IDs.

-To further simplify developer usage, the `attach`, `detach`, `has`, and `new`
-commands can be used without a target field, and will default to the name of
-the Git repository root directory, if one is found.
-
 In their shortest forms, *every* ReMux command is as short or
 shorter than its equivalent tmux command:

 ```sh

 #	new session
-tmux new-s -t foo
+tmux new-session -t foo
 remux n foo

-#	list sessions
+#	lists
 tmux ls
 remux l
+remux

 #	attach
 tmux a -t foo
 remux a foo

 #	has
-tmux h -t foo
-remux h foo
+tmux has -t foo
+remux has foo

 #	detach
-tmux det -t foo
+tmux detach-client -t foo
 remux d foo

-#	nesting sessions with '-n' flag
-TMUX='' tmux a -t foo
-remux a -n foo
-TMUX='' tmux new-session -t foo
-remux n -n foo
-
-#	switch to another session
-tmux swi -t foo
-rmux s foo
-
-#	cd to session path
-cd `tmux display-mes -p "#{session_path}"`
-cd `rmux p`
-
 ```

-## Dependencies
-
-ReMux depends on [tmux](https://github.com/tmux/tmux).
-
-## Installation
-
-### Manual Install
-
-<details>
-<summary>Release Binary</summary>
-Copy the compiled binary from the <a href="https://git.vwolfe.io/valerie/remux/releases">releases page</a>
-to a directory in <code>$PATH</code>, such as <code>/usr/bin/</code>.
-</details>
-
-<details>
-<summary>Compile from Source</summary>
-Compile using cargo with the command <code>cargo build --release</code> and copy
-the file from <code>target/release/</code> to a directory in <code>$PATH</code>,
-such as <code>/usr/bin/</code>.
-</details>
-
-<details>
-<summary>makepkg (AUR)</summary>
-Clone the <a href="https://aur.archlinux.org/remux.git">AUR Repository</a> and
-run the command <code>makepkg --install</code>.
-</details>
-
-### Package Managers
-
-<details>
-<summary>Arch Linux (AUR): <code>remux</code></summary>
-Install the package from the <a href="https://aur.archlinux.org/packages/remux"><code>remux</code> AUR Package</a>
-using an AUR package manager such as <a href="https://github.com/Morganamilo/paru"><code>paru</code></a>.
-</details>
-
-<details>
-<summary>Cargo: <code>tmux-remux</code></summary>
-Install the package using Cargo with the command <code>cargo install tmux-remux</code>.
-</details>
-
-### Supplemental
-
-<details>
-<summary>Bash Completions</summary>
-Copy <code>bash-completion/remux</code> to the appropriate directory, typically
-<code>/usr/share/bash-completion</code>.
-</details>
-
-<details>
-<summary>Man Page: Section 1</summary>
-Copy <code>man/remux.1</code> into <code>/usr/share/man/man1/</code>.
-</details>
-
-## Configuration
-
-The pretty-print attached symbol (default: `*`) can be set manually by setting `REMUX_ATTACH_SYMBOL`.
-
 ## Libraries

 - [pico-args](https://crates.io/crates/pico_args) — argument parsing
- [termion](https://crates.io/crates/termion) — ANSI formatting
 - [tmux_interface](https://crates.io/crates/tmux_interface) — tmux communication
+- [termion](https://crates.io/crates/termion) — ANSI formatting

--- a/bash-completion/remux
+++ b/bash-completion/remux
@ -1,19 +0,0 @@
-_remux() {
-	local word
-	COMPREPLY=()
-	word="${COMP_WORDS[COMP_CWORD]}"
-
-	case $COMP_CWORD in
-	1)
-		COMPREPLY=( `compgen -W 'attach detach has help list new path switch title' -- "$word"` )
-		;;
-	2)
-		COMPREPLY=( `compgen -W "$(remux l -q $word)"` )
-		;;
-	esac
-
-	return 0
-}
-
-complete -F _remux remux
-
--- a/deny.toml
+++ b/deny.toml
@ -1,4 +0,0 @@
-[licenses]
-allow = [ "MIT" ]
-
-
--- a/man/remux.1
+++ b/man/remux.1
@ -1,179 +0,0 @@
-.Dd $Mdocdate$
-.Dt REMUX 1
-.Sh NAME
-.Nm remux
-.Nd a command shortener for
-.Xr tmux 1
-.Sh SYNOPSIS
-.Nm remux
-.Op Fl dhnqrtv
-.Op Fl D Ar path
-.Op Ar command
-.Op args...
-.Sh DESCRIPTION
-.Nm
-is a wrapper and command shortener for
-.Xr tmux 1 ,
-primarily focused on improving the ergonomics of using named sessions.
-.Pp
-If no command is provided, remux will use the context action. Inside a repository, remux will attach or create. If in a session or outside a repository, remux will list sessions.
-.Sh COMMANDS
-.Nm remux
-commands are split into two categories: global commands, which can be used anywhere, and session commands, which can only be used from inside a session.
-.Ss GLOBAL COMMANDS
-.Bl -tag -width Ds
-.It Xo Ic attach
-.Op Fl dnr
-.Op Ar title
-.Op Ar window
-.Xc
-.Bd -literal -compact
-aliases: a
-Attaches to an existing session.
-.Ed
-.Pp
-.Bl -tag -width Ds -compact
-.It Fl d , Fl -detach
-Detach all other connections to the session.
-.It Fl D , Fl -dir Ar path
-Sets the working directory for the given command.
-.It Fl n , Fl -nest
-Allow nesting (attaching a session from inside another session).
-.It Fl r , Fl -read-only
-Attach the session in read-only mode.
-.It Ar title
-The title of the target session. If not given, remux will try to use the name of the repository containing the current directory.
-.It Ar window
-The name of the window to attach to.
-.El
-.It Xo Ic detach
-.Op Ar title
-.Xc
-.Bd -literal -compact
-aliases: d
-Detaches all clients from the target session.
-.Ed
-.It Xo Ic has
-.Op Fl q
-.Op Ar title
-.Xc
-.Bd -literal -compact
-aliases: h
-Checks whether or not a session exists.
-.Ed
-.Pp
-.Bl -tag -width Ds -compact
-.It Fl q , Fl -quiet
-Run silently without printing to standard output.
-.It Ar title
-The title of the target session. If not given, remux will attempt to use the name of the repository containing the current directory.
-.El
-.It Ic list
-.Bd -literal -compact
-aliases: l, ls
-Pretty-prints a list of tmux sessions.
-.Ed
-.It Xo Ic new
-.Op Fl dn
-.Op Fl t\ |\ --target Ar path
-.Op Ar title
-.Op Ar command
-.Xc
-.Bd -literal -compact
-aliases: n
-Creates a new session.
-.Ed
-.Pp
-.Bl -tag -width Ds -compact
-.It Fl d , Fl -detach
-Creates the session without attaching.
-.It Fl n , Fl -nest
-Allow nesting (attaching a session from inside another session).
-.It Fl t , Fl -target Ar path
-Sets the session path to the provided directory.
-.It Ar title
-Create the session with the given title. If not given, remux will attempt to use the name of the repository containing the current directory.
-.El
-.El
-.Ss SESSION COMMANDS
-.Bl -tag -width Ds
-.It Ic path
-.Bd -literal -compact
-aliases: p
-Prints the session path.
-.Ed
-.It Xo Ic switch
-.Op Fl rd
-.Op Ar title
-.Xc
-.Bd -literal -compact
-aliases: s
-Switches from the current session to the target.
-.Ed
-.Pp
-.Bl -tag -width Ds -compact
-.It Fl d , Fl -detach
-Detaches other clients from the target session.
-.It Fl r , Fl -read-only
-Switch to the target session in read-only mode.
-.It Ar title
-The title of the session to switch to. If blank, the previous session will be used.
-.El
-.It Ic title
-.Bd -literal -compact
-aliases: t, which
-Prints the session title.
-.El
-.Sh ENVIRONMENT
-.Bl -tag -width Ds
-.It Ev REMUX_ATTACH_SYMBOL
-Changes the symbol displayed for attached sessions in the
-.Ic list
-command.
-Default: '*'
-.It Ev REMUX_CURRENT_SYMBOL
-Changes the symbol displayed for the current session in the
-.Ic list
-command.
-Default: '>'
-.It Ev REMUX_NEW_WINDOW
-Provides a default windows name when creating a new session. Unused if empty.
-Default: (unset)
-.It Ev REMUX_PREVIOUS_SYMBOL
-Changes the symbol displayed for the previous session in the
-.Ic list
-command.
-Default: '-'
-.It Ev REMUX_REPO_FILE
-The filename to match on when trying to find the root of a repository.
-Default: '.git'
-.El
-.Sh EXIT STATUS
-.Bl -tag -Width Ds
-.It 1
-Unmatched command name.
-.It 2
-Unmatched target session.
-.It 3
-Unmatched help topic.
-.It 4
-Missing or invalid target; target was not given or is the same as the current session.
-.It 5
-.Nm remux
-is not running from within a terminal.
-.It 6
-Nesting error; nest flag is missing or inappropriate.
-.It 7
-A session command was attempted outside a session.
-.Sh EXAMPLES
-Use
-.Ic path
-to navigate to the session path:
-.Pp
-.Dl $ cd `remux p`
-.Pp
-.Sh SEE ALSO
-.Xr tmux 1
-.Sh AUTHORS
-.An -nosplit
-.An Valerie Wolfe Aq Mt sleeplessval@gmail.com
--- a/sbom.xml
+++ b/sbom.xml
@ -1,260 +0,0 @@
-{
-  "SPDXID": "SPDXRef-DOCUMENT",
-  "creationInfo": {
-    "created": "2024-03-14T20:41:35.559Z",
-    "creators": [
-      "Tool: cargo-sbom-v0.8.4"
-    ]
-  },
-  "dataLicense": "CC0-1.0",
-  "documentNamespace": "https://spdx.org/spdxdocs/remux-eb288ebb-1cdd-412b-87c2-b15fc96cd8bd",
-  "files": [
-    {
-      "SPDXID": "SPDXRef-File-remux",
-      "checksums": [],
-      "fileName": "remux",
-      "fileTypes": [
-        "BINARY"
-      ]
-    }
-  ],
-  "name": "remux",
-  "packages": [
-    {
-      "SPDXID": "SPDXRef-Package-libredox-0.0.2",
-      "description": "Redox stable ABI",
-      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
-      "externalRefs": [
-        {
-          "referenceCategory": "PACKAGE-MANAGER",
-          "referenceLocator": "pkg:cargo/libredox@0.0.2",
-          "referenceType": "purl"
-        }
-      ],
-      "licenseConcluded": "MIT",
-      "licenseDeclared": "MIT",
-      "name": "libredox",
-      "versionInfo": "0.0.2"
-    },
-    {
-      "SPDXID": "SPDXRef-Package-libc-0.2.153",
-      "description": "Raw FFI bindings to platform libraries like libc.\n",
-      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
-      "externalRefs": [
-        {
-          "referenceCategory": "PACKAGE-MANAGER",
-          "referenceLocator": "pkg:cargo/libc@0.2.153",
-          "referenceType": "purl"
-        }
-      ],
-      "homepage": "https://github.com/rust-lang/libc",
-      "licenseConcluded": "MIT OR Apache-2.0",
-      "licenseDeclared": "MIT OR Apache-2.0",
-      "name": "libc",
-      "versionInfo": "0.2.153"
-    },
-    {
-      "SPDXID": "SPDXRef-Package-numtoa-0.1.0",
-      "description": "Convert numbers into stack-allocated byte arrays",
-      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
-      "externalRefs": [
-        {
-          "referenceCategory": "PACKAGE-MANAGER",
-          "referenceLocator": "pkg:cargo/numtoa@0.1.0",
-          "referenceType": "purl"
-        }
-      ],
-      "licenseConcluded": "MIT OR Apache-2.0",
-      "licenseDeclared": "MIT OR Apache-2.0",
-      "name": "numtoa",
-      "versionInfo": "0.1.0"
-    },
-    {
-      "SPDXID": "SPDXRef-Package-termion-2.0.3",
-      "description": "A bindless library for manipulating terminals.",
-      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
-      "externalRefs": [
-        {
-          "referenceCategory": "PACKAGE-MANAGER",
-          "referenceLocator": "pkg:cargo/termion@2.0.3",
-          "referenceType": "purl"
-        }
-      ],
-      "licenseConcluded": "MIT",
-      "licenseDeclared": "MIT",
-      "name": "termion",
-      "versionInfo": "2.0.3"
-    },
-    {
-      "SPDXID": "SPDXRef-Package-pico-args-0.5.0",
-      "description": "An ultra simple CLI arguments parser.",
-      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
-      "externalRefs": [
-        {
-          "referenceCategory": "PACKAGE-MANAGER",
-          "referenceLocator": "pkg:cargo/pico-args@0.5.0",
-          "referenceType": "purl"
-        }
-      ],
-      "licenseConcluded": "MIT",
-      "licenseDeclared": "MIT",
-      "name": "pico-args",
-      "versionInfo": "0.5.0"
-    },
-    {
-      "SPDXID": "SPDXRef-Package-redox_termios-0.1.3",
-      "description": "A Rust library to access Redox termios functions",
-      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
-      "externalRefs": [
-        {
-          "referenceCategory": "PACKAGE-MANAGER",
-          "referenceLocator": "pkg:cargo/redox_termios@0.1.3",
-          "referenceType": "purl"
-        }
-      ],
-      "licenseConcluded": "MIT",
-      "licenseDeclared": "MIT",
-      "name": "redox_termios",
-      "versionInfo": "0.1.3"
-    },
-    {
-      "SPDXID": "SPDXRef-Package-remux-0.2.1",
-      "description": "A friendly command shortener for tmux",
-      "downloadLocation": "NONE",
-      "homepage": "https://git.vwolfe.io/valerie/remux",
-      "licenseConcluded": "MIT",
-      "licenseDeclared": "MIT",
-      "name": "remux",
-      "versionInfo": "0.2.1"
-    },
-    {
-      "SPDXID": "SPDXRef-Package-bitflags-2.4.2",
-      "description": "A macro to generate structures which behave like bitflags.\n",
-      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
-      "externalRefs": [
-        {
-          "referenceCategory": "PACKAGE-MANAGER",
-          "referenceLocator": "pkg:cargo/bitflags@2.4.2",
-          "referenceType": "purl"
-        }
-      ],
-      "homepage": "https://github.com/bitflags/bitflags",
-      "licenseConcluded": "MIT OR Apache-2.0",
-      "licenseDeclared": "MIT OR Apache-2.0",
-      "name": "bitflags",
-      "versionInfo": "2.4.2"
-    },
-    {
-      "SPDXID": "SPDXRef-Package-bitflags-1.3.2",
-      "description": "A macro to generate structures which behave like bitflags.\n",
-      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
-      "externalRefs": [
-        {
-          "referenceCategory": "PACKAGE-MANAGER",
-          "referenceLocator": "pkg:cargo/bitflags@1.3.2",
-          "referenceType": "purl"
-        }
-      ],
-      "homepage": "https://github.com/bitflags/bitflags",
-      "licenseConcluded": "MIT OR Apache-2.0",
-      "licenseDeclared": "MIT/Apache-2.0",
-      "name": "bitflags",
-      "versionInfo": "1.3.2"
-    },
-    {
-      "SPDXID": "SPDXRef-Package-redox_syscall-0.4.1",
-      "description": "A Rust library to access raw Redox system calls",
-      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
-      "externalRefs": [
-        {
-          "referenceCategory": "PACKAGE-MANAGER",
-          "referenceLocator": "pkg:cargo/redox_syscall@0.4.1",
-          "referenceType": "purl"
-        }
-      ],
-      "licenseConcluded": "MIT",
-      "licenseDeclared": "MIT",
-      "name": "redox_syscall",
-      "versionInfo": "0.4.1"
-    },
-    {
-      "SPDXID": "SPDXRef-Package-tmux_interface-0.2.1",
-      "description": "Rust language library for communication with TMUX via CLI",
-      "downloadLocation": "registry+https://github.com/rust-lang/crates.io-index",
-      "externalRefs": [
-        {
-          "referenceCategory": "PACKAGE-MANAGER",
-          "referenceLocator": "pkg:cargo/tmux_interface@0.2.1",
-          "referenceType": "purl"
-        }
-      ],
-      "licenseConcluded": "MIT",
-      "licenseDeclared": "MIT",
-      "name": "tmux_interface",
-      "versionInfo": "0.2.1"
-    }
-  ],
-  "relationships": [
-    {
-      "relatedSpdxElement": "SPDXRef-Package-libc-0.2.153",
-      "relationshipType": "DEPENDS_ON",
-      "spdxElementId": "SPDXRef-Package-termion-2.0.3"
-    },
-    {
-      "relatedSpdxElement": "SPDXRef-Package-termion-2.0.3",
-      "relationshipType": "DEPENDS_ON",
-      "spdxElementId": "SPDXRef-Package-remux-0.2.1"
-    },
-    {
-      "relatedSpdxElement": "SPDXRef-Package-redox_syscall-0.4.1",
-      "relationshipType": "DEPENDS_ON",
-      "spdxElementId": "SPDXRef-Package-libredox-0.0.2"
-    },
-    {
-      "relatedSpdxElement": "SPDXRef-Package-numtoa-0.1.0",
-      "relationshipType": "DEPENDS_ON",
-      "spdxElementId": "SPDXRef-Package-termion-2.0.3"
-    },
-    {
-      "relatedSpdxElement": "SPDXRef-Package-tmux_interface-0.2.1",
-      "relationshipType": "DEPENDS_ON",
-      "spdxElementId": "SPDXRef-Package-remux-0.2.1"
-    },
-    {
-      "relatedSpdxElement": "SPDXRef-Package-pico-args-0.5.0",
-      "relationshipType": "DEPENDS_ON",
-      "spdxElementId": "SPDXRef-Package-remux-0.2.1"
-    },
-    {
-      "relatedSpdxElement": "SPDXRef-Package-redox_termios-0.1.3",
-      "relationshipType": "DEPENDS_ON",
-      "spdxElementId": "SPDXRef-Package-termion-2.0.3"
-    },
-    {
-      "relatedSpdxElement": "SPDXRef-Package-libc-0.2.153",
-      "relationshipType": "DEPENDS_ON",
-      "spdxElementId": "SPDXRef-Package-libredox-0.0.2"
-    },
-    {
-      "relatedSpdxElement": "SPDXRef-Package-bitflags-1.3.2",
-      "relationshipType": "DEPENDS_ON",
-      "spdxElementId": "SPDXRef-Package-redox_syscall-0.4.1"
-    },
-    {
-      "relatedSpdxElement": "SPDXRef-Package-remux-0.2.1",
-      "relationshipType": "GENERATED_FROM",
-      "spdxElementId": "SPDXRef-File-remux"
-    },
-    {
-      "relatedSpdxElement": "SPDXRef-Package-bitflags-2.4.2",
-      "relationshipType": "DEPENDS_ON",
-      "spdxElementId": "SPDXRef-Package-libredox-0.0.2"
-    },
-    {
-      "relatedSpdxElement": "SPDXRef-Package-libredox-0.0.2",
-      "relationshipType": "DEPENDS_ON",
-      "spdxElementId": "SPDXRef-Package-termion-2.0.3"
-    }
-  ],
-  "spdxVersion": "SPDX-2.3"
-}
--- a/src/command.rs
+++ b/src/command.rs
@ -0,0 +1,159 @@
+use std::{
+	env::current_dir,
+	process::exit
+};
+
+use pico_args::Arguments;
+use termion::{ color, style };
+use tmux_interface::TmuxCommand;
+
+use crate::error;
+use crate::util;
+
+pub fn attach(pargs: &mut Arguments) {
+	util::prevent_nest();
+
+	//	get optional flags
+	let read_only = pargs.contains(["-r", "--readonly"]);
+	let detach_other = pargs.contains(["-d", "--detach"]);
+
+	//	get target and error out if not provided
+	let args = pargs.clone().finish();
+	if args.len() < 1 { error::missing_target(); }
+	let target = args.get(0).unwrap().to_string_lossy();
+	let window = args.get(1);
+
+	//	focus window if provided
+	if window.is_some() {
+		let target = window.unwrap().to_string_lossy();
+		let tmux = TmuxCommand::new();
+		tmux
+			.select_window()
+			.target_window(target)
+			.output().ok();
+	}
+
+	//	command
+	let tmux = TmuxCommand::new();
+	let exists = tmux
+		.has_session()
+		.target_session(target.clone())
+		.output().unwrap();
+	if !exists.success() { error::no_target(target.to_string()); }
+
+	let mut attach = tmux.attach_session();
+
+	//	handle optional flags
+	if read_only { attach.read_only(); }
+	if detach_other { attach.detach_other(); }
+
+	attach
+		.target_session(target)
+		.output().ok();
+}
+
+pub fn detach(pargs: &mut Arguments) {
+	//	get target and error out if not provided
+	let args = pargs.clone().finish();
+	if args.len() < 1 { error::missing_target(); }
+	let target = args.get(0).unwrap().to_string_lossy();
+
+	//	command
+	let tmux = TmuxCommand::new();
+	let exists = tmux
+		.has_session()
+		.target_session(target.clone())
+		.output().unwrap();
+	if !exists.success() { error::no_target(target.to_string()); }
+
+	tmux
+		.detach_client()
+		.target_session(target)
+		.output().ok();
+}
+
+pub fn has(pargs: &mut Arguments) {
+	//	get optional flag
+	let quiet = pargs.contains(["-q", "--quiet"]);
+
+	//	get target and error out if not provided
+	let args = pargs.clone().finish();
+	if args.len() < 1 { error::missing_target(); }
+	let target = args.get(0).unwrap().to_string_lossy();
+
+	//	command
+	let tmux = TmuxCommand::new();
+	let exists = tmux
+		.has_session()
+		.target_session(target.clone())
+		.output().unwrap();
+
+	let success = exists.success();
+
+	//	handle optional flag
+	//	inverted; print text if NOT quiet
+	if !quiet { println!("session \"{target}\" {}.", if success { "exists" } else { "does not exist" }); }
+
+	//	exit codes for scripts to use
+	exit( if success { 0 } else { 1 });
+}
+
+pub fn list() {
+	//	get session list
+	let sessions = util::get_sessions().unwrap_or(Vec::new());
+
+	//	handle empty case
+	if sessions.len() == 0 {
+		println!("no sessions");
+		return;
+	}
+
+	//	iterate over pretty print
+	println!("sessions:");
+	for session in sessions.into_iter() {
+		let group = session.group.unwrap_or("[untitled]".to_string());
+		let id = session.id.unwrap();
+		let attached = session.attached.unwrap_or(0) > 0;
+
+		println!(
+			"  {group} ({bold}{blue}{id}{reset}) {bold}{green}{attach_sym}{reset}",
+			//	values
+			attach_sym = if attached { "󰌹" } else {""},
+			//	formatting
+			bold = style::Bold,
+			blue = color::Fg(color::Blue),
+			green = color::Fg(color::LightGreen),
+			reset = style::Reset
+		);
+	}
+}
+
+pub fn new(pargs: &mut Arguments) {
+	use pico_args::Error;
+
+	//	show nest message
+	util::prevent_nest();
+
+	//	get optional flag
+	let target_dir: Result<String, Error> = pargs.value_from_str(["-t", "--target"]);
+
+	//	get target and error out if not provided
+	let args = pargs.clone().finish();
+	if args.len() < 1 { error::missing_target(); }
+
+	//	get target session and optional command
+	let title = args.get(0).unwrap().to_string_lossy();
+	let command = args.get(1);
+
+	let tmux = TmuxCommand::new();
+	let mut new = tmux.new_session();
+
+	if command.is_some() { new.shell_command(command.unwrap().to_string_lossy()); }
+
+	new
+		.group_name(title)
+		.attach()
+		.start_directory(target_dir.unwrap_or(current_dir().unwrap().to_string_lossy().to_string()))
+		.output().ok();
+}
+
--- a/src/command/mod.rs
+++ b/src/command/mod.rs
@ -1,4 +0,0 @@
-
-pub mod share;
-pub mod session;
-
--- a/src/command/session.rs
+++ b/src/command/session.rs
@ -1,67 +0,0 @@
-//!	commands accessible from within a session
-
-use tmux_interface::{
-	Tmux,
-	commands
-};
-
-use crate::{
-	error,
-	state::State,
-	util::{
-		self,
-		message,
-		MSG_PREVIOUS, MSG_SESSION_PATH, NULL
-	}
-};
-
-pub fn path(state: &mut State) {
-	state.session_enforce("path");
-
-	if let Some(message) = message(MSG_SESSION_PATH) {
-		println!("{message}");
-	}
-}
-
-pub fn switch(state: &mut State) {
-	util::terminal_enforce();
-	//	refuse to run outside a session
-	state.session_enforce("switch");
-
-	//	consume optional flags
-	let read_only = state.flags.read_only;
-	let detach_other = state.flags.detached;
-
-	let args = state.args.clone().finish();
-	let target: String = match if let Some(inner) = args.get(0) { inner.to_str() } else { None } {
-		None		|
-		Some("-")	=>	if let Some(prev) = message(MSG_PREVIOUS) { prev }
-						else { error::missing_target() },
-
-		Some(inner)	=>	inner.to_owned()
-	};
-
-	let exists = util::session_exists(target.clone());
-	if !exists { error::no_target(target.clone()); }
-
-	let mut tmux = Tmux::new();
-
-	if detach_other {
-		let detach = commands::DetachClient::new()
-			.target_session(&target);
-		tmux = tmux.add_command(detach);
-	}
-
-	let mut switch = commands::SwitchClient::new();
-	switch = switch.target_session(&target);
-	if read_only { switch.read_only = true; }
-
-	tmux.add_command(switch)
-		.stderr(NULL).output().ok();
-}
-
-pub fn title(state: State) {
-	state.session_enforce("title");
-	if let Some(title) = state.title { println!("{title}"); }
-}
-
--- a/src/command/share.rs
+++ b/src/command/share.rs
@ -1,216 +0,0 @@
-//! globally available tmux commands.
-use std::process::exit;
-
-use pico_args::{ Arguments, Error };
-use termion::{ color, style };
-use tmux_interface::{
-	Tmux,
-	commands
-};
-
-use crate::{
-	env::{
-		self,
-		env_var,
-		SYMBOL_ATTACH, SYMBOL_CURRENT, SYMBOL_PREV
-	},
-	error,
-	flag,
-	state::State,
-	util::{
-		self,
-		message,
-		MSG_PREVIOUS, NULL
-	}
-};
-
-pub fn attach(state: &mut State) {
-	util::terminal_enforce();
-	state.nest_init();
-
-	//	consume optional flags
-	let read_only = state.flags.read_only;
-	let detach_other = state.flags.detached;
-
-	//	consume arguments
-	let target = state.target_title().unwrap();
-	let window = state.target();
-
-	//	do not allow attaching to the same session
-	if state.session && target == state.title.clone().unwrap() { error::same_session(); }
-
-	//	make sure the session exists
-	let exists = util::session_exists(target.clone());
-	if !exists { error::no_target(target.clone()); }
-
-	//	 build attach command
-	let mut attach = commands::AttachSession::new();
-	attach = attach.target_session(target);
-	if read_only { attach.read_only = true; }
-	if detach_other { attach.detach_other = true; }
-
-	let select_window: Option<commands::SelectWindow>;
-	if let Some(window) = window {
-		let mut command = commands::SelectWindow::new();
-		command.target_window = Some(window.into());
-		select_window = Some(command);
-	} else { select_window = None; }
-
-	//	build dispatch
-	let mut tmux = Tmux::new().add_command(attach);
-	if let Some(select_window) = select_window { tmux = tmux.add_command(select_window); }
-	tmux.stderr(NULL).output().ok();
-
-	state.nest_deinit();
-}
-
-pub fn context_action(state: &mut State) {
-	if !state.session {
-		if let Some(repository) = &state.repository {
-			let target = repository.name.clone();
-			let mut args = Arguments::from_vec( vec![(&target).into()] );
-			let mut substate = State::new(&mut args);
-			substate.flags = state.flags.clone();
-			if util::session_exists(&target) {
-				attach(&mut substate);
-			} else {
-				new(&mut substate);
-			}
-			return;
-		}
-	}
-	//	fallback behavior is list
-	list(state);
-}
-
-pub fn detach(state: &mut State) {
-	util::terminal_enforce();
-
-	let target = state.target_title().unwrap();
-
-	//	make sure the session exists
-	let exists = util::session_exists(target.clone());
-	if !exists { error::no_target(target.clone()); }
-
-	//	build and dispatch
-	let detach = commands::DetachClient::new()
-		.target_session(target);
-	Tmux::new()
-		.add_command(detach)
-		.disable_echo().output().ok();
-}
-
-pub fn has(state: &mut State) {
-	//	consume optional flags
-	let quiet = state.flags.quiet;
-
-	//	get target
-	let target = state.target_title().unwrap();
-
-	//	run command
-	let success = util::session_exists(target.clone());
-
-	//	print if not quiet
-	if !quiet {
-		println!("session \"{target}\" {}.",
-			if success { "exists" }
-			else { "does not exist" }
-		);
-	}
-
-	//	emit exit code
-	exit( if success { 0 } else { 1 });
-}
-
-pub fn list(state: &mut State) {
-	//	get session list
-	let sessions = util::get_sessions().unwrap_or(Vec::new());
-
-	let search = state.target();
-	let previous = message(MSG_PREVIOUS);
-
-	//	handle empty case
-	if sessions.len() == 0 {
-		if !state.flags.quiet { println!("no sessions"); }
-		return;
-	}
-
-	//	get attached session symbol
-	let attach_symbol	= env_var(SYMBOL_ATTACH);
-	let current_symbol	= env_var(SYMBOL_CURRENT);
-	let prev_symbol		= env_var(SYMBOL_PREV);
-
-	//	pretty print session list
-	if !state.flags.quiet { println!("sessions:"); }
-	for session in sessions {
-		let name = session.name.unwrap_or("[untitled]".to_string());
-
-		if search.is_some() && !name.starts_with(search.as_ref().unwrap()) { continue; }
-
-		if !state.flags.quiet {
-			let id = session.id.unwrap();
-
-			let attached = session.attached.unwrap_or(0) > 0;
-
-			let compare = Some(name.clone());
-			let marker =
-				if compare == state.title { current_symbol.clone() }
-				else if state.session && compare == previous { prev_symbol.clone() }
-				else { " ".to_string() };
-
-			println!(
-				" {marker} {name}{reset} ({bold}{blue}{id}{reset}) {bold}{green}{attach}{reset}",
-				//	values
-				attach		= if attached { attach_symbol.clone() } else { "".to_string() },
-				//	formatting
-				bold		= style::Bold,
-				blue		= color::Fg(color::Blue),
-				green		= color::Fg(color::LightGreen),
-				reset		= style::Reset,
-			);
-		} else {
-			print!("{name} ");
-		}
-	}
-}
-
-pub fn new(state: &mut State) {
-	util::terminal_enforce();
-
-	//	get optional flags
-	let detached = state.flags.detached;
-	let target_dir: Result<String, Error> = state.args.value_from_str(flag::TARGET);
-
-	//	delayed nest_init; detached behavior conflicts with nest
-	if !detached { state.nest_init(); }
-	else if state.flags.nested { error::conflict_nest(Some("detached session is not nesting")); }
-
-	//	get environment variables
-	let window_name = env_var(env::NEW_WINDOW_NAME);
-
-	//	consume arguments
-	let title = state.target_title().unwrap();
-	let command = state.target();
-
-	//	don't allow duplicate names
-	let exists = util::session_exists(title.clone());
-	if exists { error::target_exists(title.clone()); }
-
-	let mut new = commands::NewSession::new();
-	new = new.session_name(title);
-	if let Some(command) = command { new.shell_command = Some(command.into()); }
-	if detached { new.detached = true; }
-	if let Ok(target_dir) = target_dir { new = new.start_directory(target_dir); }
-
-	let mut tmux = Tmux::new().add_command(new);
-
-	//	rename window if var not empty
-	if !window_name.is_empty() {
-		let auto_name = commands::RenameWindow::new()
-			.new_name(window_name);
-		tmux = tmux.add_command(auto_name);
-	}
-
-	tmux.stderr(NULL).output().ok();
-}
-
--- a/src/env.rs
+++ b/src/env.rs
@ -1,17 +0,0 @@
-use std::env::var;
-
-pub type EnvVar = (&'static str, &'static str);
-
-pub const NEW_WINDOW_NAME:	EnvVar	= ("REMUX_NEW_WINDOW", "");
-pub const REPO_FILE:		EnvVar	= ("REMUX_REPO_FILE", ".git");
-pub const SYMBOL_ATTACH:	EnvVar	= ("REMUX_ATTACH_SYMBOL", "*");
-pub const SYMBOL_CURRENT:	EnvVar	= ("REMUX_CURRENT_SYMBOL", ">");
-pub const SYMBOL_PREV:		EnvVar	= ("REMUX_PREVIOUS_SYMBOL", "-");
-
-pub const TMUX: &str				= "TMUX";
-
-///	get or default an environment variable
-pub fn env_var(envvar: EnvVar) -> String {
-	var(envvar.0).unwrap_or(envvar.1.to_string())
-}
-
--- a/src/error.rs
+++ b/src/error.rs
@ -1,84 +1,38 @@
 use std::process::exit;

 ///	no subcommand that matches user input; code 1
-pub fn no_subcommand(subcommand: String) -> ! {
-	eprintln!("remux: no command match for \"{subcommand}\"");
+pub fn no_subcommand(subcommand: String) {
+	println!("remux: no command match for \"{subcommand}\"");
 	exit(1);
 }

-
 ///	target session not found; code 2
-pub fn no_target<S: Into<String>>(target: S) -> ! {
-	let target = target.into();
-	eprintln!("remux: no session \"{target}\" exists");
+pub fn no_target(target: String) {
+	println!("remux: no session \"{target}\" exists");
 	exit(2);
 }

-
 ///	help topic doesn't exist; code 3
-pub fn no_help(topic: String) -> ! {
-	eprintln!("remux: no help for \"{topic}\"");
+pub fn no_help(topic: String) {
+	println!("remux: no help for \"{topic}\"");
 	exit(3);
 }

-
 ///	user provided no target; code 4
-pub fn missing_target() -> ! {
-	eprintln!("remux: no target provided");
+pub fn missing_target() {
+	println!("remux: no target provided");
 	exit(4);
 }

-///	refuse to attach to current session; code 4
-pub fn same_session() -> ! {
-	eprintln!("remux: cannot attach to same session");
-	exit(4);
-}
-
-///	a session with the target name already exists; code 4
-pub fn target_exists<S: Into<String>>(target: S) -> ! {
-	let target = target.into();
-	eprintln!("remux: session \"{target}\" already exists");
-	exit(4);
-}
-
-
 ///	non-terminal environment prevention; code 5
-pub fn not_terminal() -> ! {
-	eprintln!("remux: not running from a terminal");
+pub fn not_terminal() {
+	println!("remux: not running from a terminal");
 	exit(5);
 }

-
 ///	tried to nest while not in a session; code 6
-pub fn not_nesting() -> ! {
-	eprintln!("remux: inappropriate nesting flag (-n); not in a session");
+pub fn not_nesting() {
+	println!("remux: cannot use nesting flag outside a TMUX session");
 	exit(6);
 }

-///	operation requires nesting flag; code 6
-pub fn prevent_nest() -> ! {
-	eprintln!("remux: the nesting flag (-n) is required for nesting operation");
-	exit(6);
-}
-
-///	operation conflicts with nesting flag; code 6
-pub fn conflict_nest(reason: Option<&'static str>) -> ! {
-	if let Some(reason) = reason { eprintln!("remux: inappropriate nesting flag (-n): {reason}"); }
-	else { eprintln!("remux: nesting flag (-n) is inappropriate for this operation."); }
-	exit(6);
-}
-
-
-///	tried to run a session command outside a session; code 7
-pub fn not_in_session(cmd: &'static str) -> ! {
-	eprintln!("remux: '{cmd}' must be run from within a session");
-	exit(7);
-}
-
-
-///	failed to set working directory; code 8
-pub fn working_dir_fail(working_dir: &str) -> ! {
-	eprintln!("remux: failed to set working directory to '{working_dir}'");
-	exit(8);
-}
-
--- a/src/flag.rs
+++ b/src/flag.rs
@ -1,56 +0,0 @@
-
-use pico_args::Arguments;
-
-type Flag = [&'static str;2];
-
-pub static DETACH: Flag			= [ "-d", "--detach" ];
-pub static HELP: Flag			= [ "-h", "--help" ];
-pub static NEST: Flag			= [ "-n", "--nest" ];
-pub static QUIET: Flag			= [ "-q", "--quiet" ];
-pub static READ_ONLY: Flag		= [ "-r", "--read-only" ];
-pub static TARGET: Flag			= [ "-t", "--target" ];
-pub static VERSION: Flag		= [ "-v", "--version" ];
-pub static WORKING_DIR: Flag	= [ "-D", "--dir" ];
-
-pub struct Flags {
-	pub detached: bool,
-	pub nested: bool,
-	pub quiet: bool,
-	pub read_only: bool,
-	pub target: Option<String>,
-	pub working_dir: Option<String>
-}
-
-impl Flags {
-
-	pub fn from(args: &mut Arguments) -> Flags {
-		let detached	= args.contains(DETACH);
-		let nested		= args.contains(NEST);
-		let quiet		= args.contains(QUIET);
-		let read_only	= args.contains(READ_ONLY);
-		let target		= args.value_from_str(TARGET).ok();
-		let working_dir	= args.value_from_str(WORKING_DIR).ok();
-
-		Flags {
-			detached,
-			nested,
-			quiet,
-			read_only,
-			target,
-			working_dir
-		}
-	}
-
-	pub fn clone(&self) -> Flags {
-		Flags {
-			detached: self.detached,
-			nested: self.nested,
-			quiet: self.quiet,
-			read_only: self.read_only,
-			target: self.target.clone(),
-			working_dir: self.working_dir.clone()
-		}
-	}
-
-}
-
--- a/src/help.rs
+++ b/src/help.rs
@ -8,157 +8,90 @@ pub fn help(pargs: &mut Arguments) {
 	let topic = pargs.subcommand().unwrap();

 	match topic.as_deref() {
-		None =>
-println!("remux v{VERSION}
-Valerie Wolfe <sleeplessval@gmail.com>
-A command wrapper for tmux written in Rust.
+		None => {
+			println!("remux v{VERSION}");
+			println!("Valerie Wolfe <sleeplessval@gmail.com>");
+			println!("A command wrapper for tmux written in Rust.\n");

-usage: remux [command] [<args>]
+			println!("usage: remux <command> [<args>]\n");

-commands:
-   help       Show help text for remux, a command, or a help topic.
-   attach     Attach to an existing tmux session
-   detach     Detach clients from a tmux session
-   has        Check if a tmux session exists
-   list       Pretty-print all tmux sessions
-   new        Create a new tmux session
+			println!("Commands:");
+			println!("   help       Show help text for remux or a specific command");
+			println!("   attach     Attach to an existing tmux session");
+			println!("   detach     Detach clients from a tmux session");
+			println!("   has        Check if a tmux session exists");
+			println!("   list       Pretty-print all tmux sessions");
+			println!("   new        Create a new tmux session");

-   path       print session path (session)
-   switch     switch to another session (session)
-   title      print session title (session)
-
-Use 'remux help <command>' to see detailed help text for each command.
-
-help topics:
-   env        Environment variables"),
+			println!("\nUse 'remux help <command>' to see detailed help text for each command.");
+		},


-//	COMMAND HELP
+		Some("a" | "attach")
+		=> {
+			println!("remux attach");
+			println!("Attach to an existing session.\n");

-	Some("a" | "attach")
-		=>
-println!("remux attach
-Attach to an existing session.
+			println!("usage: remux attach [flags] <session> [window]\n");

-usage: remux attach [flags] <session> [window]
-       remux a [flags] <session> [window]
+			println!("args:");
+			println!("   <session>          The session to attach to");
+			println!("   [window]           Optionally focus a window in the given session\n");

-args:
-   <session>          The session to attach to
-   [window]           Optionally focus a window in the given session
-
-flags:
-   -d, --detach       Detach other attached clients from the session
-   -n, --nest         Attach the session inside another session.
-   -r, --read-only    Attach the session as read-only"),
+			println!("flags:");
+			println!("   -d, --detach       Detach other attached clients from the session");
+			println!("   -r, --readonly     Attach the session as read-only");
+		},

 		Some("d" | "detach")
-		=>
-println!("remux detach
-Detach all clients from a session.
+		=> {
+			println!("remux detach");
+			println!("Detach all clients from a session.\n");

-usage: remux detach <session>
-       remux d <session>
+			println!("usage: remux detach <session>\n");

-args:
-   <session>      The session name to detach clients from"),
+			println!("args:");
+			println!("   <session>      The session name to detach clients from");
+		},

-		Some("h" | "has")
-		=>
-println!("remux has
-Check if the target session exists.
+		Some("has")
+		=> {
+			println!("remux has");
+			println!("Check if the target session exists.\n");

-usage: remux has [flags] <session>
-       rmux h [flags] session
+			println!("usage: remux has [flags] <session>\n");

-args:
-   <session>      The session to check for
+			println!("args:");
+			println!("   <session>      The session to check for\n");

-flags:
-   -q, --quiet    Display no text; exit code only"),
+			println!("flags:");
+			println!("   -q, --quiet    Display no text; exit code only");
+		},

 		Some("l" | "ls" | "list")
-		=>
-println!("remux list
-Pretty-print all tmux sessions.
+		=> {
+			println!("remux list");
+			println!("Pretty-print all tmux sessions.\n");

-usage: remux list
-       remux ls
-       remux l"),
+			println!("usage: remux list");
+		},

 		Some("n" | "new")
-		=>
-println!("remux new
-Create a new tmux session.
+		=> {
+			println!("remux new");
+			println!("Create a new tmux session.\n");

-usage: remux new [flags] <title> [command]
-       remux n [flags] <title> [command]
+			println!("usage: remux new [flags] <title> [command]\n");

-args:
-   <title>                The title of the new session
-   [command]              The shell command to run
+			println!("args:");
+			println!("   <title>                The title of the new session");
+			println!("   [command]              The shell command to run\n");

-flags:
-   -n, --nest             Create the session inside another session.
-   -t, --target <dir>     Sets the target directory for the new session."),
+			println!("flags:");
+			println!("   -t, --target <dir>     Sets the target directory for the new session.");
+		},

-		Some("p" | "path")
-		=>
-println!("remux path
-Print the session path (#{{session_path}}) to standard output.
-Must be run from inside a session.
-
-usage: remux path
-       remux p"),
-
-		Some("s" | "switch")
-		=>
-println!("remux switch
-Switch to a different tmux session.
-Must be run from inside a session.
-
-usage: remux switch [flags] <title>
-       remux s [flags] <title>
-
-args:
-   <title>                The title of the session to switch to.
-
-flags:
-   -r, --read-only        Attach the target session as read-only."),
-
-
-		Some("w" | "which" | "title")
-			=>
-println!("remux which
-Print the title of the current session.
-
-usage: remux which
-       remux w
-       remux title"),
-
-
-//	TOPIC HELP
-
-		Some("env" | "vars")
-			=>
-println!("remux environment variables
-
-REMUX_ATTACH_SYMBOL
-   Changes the symbol displayed for attached sessions displayed
-   by the 'list' command.
-   Default: '*'
-
-REMUX_CURRENT_SYMBOL
-   Changes the symbol displayed to denote the current session
-   in the 'list' command.
-   Default: '>'
-
-REMUX_NEW_WINDOW
-   Provides a default window name when creating a session with
-   the 'new' command, if not empty.
-   Default: (unset)"),
-
-		//	not found
+								//	not found
 		_	=>	error::no_help(topic.unwrap())
 	}
 }
--- a/src/main.rs
+++ b/src/main.rs
@ -1,16 +1,16 @@
+use std::{
+	env::{ set_var, var },
+	io::{ stdout, IsTerminal }
+};

 use pico_args::Arguments;

 mod command;
-mod env;
 mod error;
-mod flag;
 mod help;
-mod state;
 mod util;

 use help::{ help, version };
-use state::State;

 static VERSION: &str = env!("CARGO_PKG_VERSION");

@ -19,54 +19,57 @@ fn main() {
 	let mut args = Arguments::from_env();

 	//	consume flags
-	if args.contains(flag::HELP) {
+	if args.contains(["-h", "--help"]) {
 		help(&mut args);
 		return;
 	}

-	if args.contains(flag::VERSION) {
+	if args.contains(["-v", "--version"]) {
 		version();
 		return;
 	}

-	let mut state = State::new(&mut args);
-
-	let target = state.target();
-
-	//	invoke subcommand function
-	match target.as_deref() {
-		Some("help")
-			=>	help(&mut args),
-		None
-			=>	command::share::context_action(&mut state),
-
-		Some("a" | "attach")
-			=>	command::share::attach(&mut state),
-
-		Some("d" | "detach")
-			=>	command::share::detach(&mut state),
-
-		Some("h" | "has")
-			=>	command::share::has(&mut state),
-
-		Some("l" | "ls" | "list")
-			=>	command::share::list(&mut state),
-
-		Some("n" | "new")
-			=>	command::share::new(&mut state),
-
-		Some("p" | "path")
-			=>	command::session::path(&mut state),
-
-		Some("s" | "switch")
-			=>	command::session::switch(&mut state),
-
-		Some("t" | "title" | "which")
-			=>	command::session::title(state),
-
-		_
-			=>	error::no_subcommand(target.unwrap())
+	let nesting = args.contains(["-n", "--nest"]);
+	let tmux_var = var("TMUX").ok();
+	if nesting {
+		if tmux_var.is_none() {
+			error::not_nesting();
+		}
+		set_var("TMUX", "");
 	}

+	if !stdout().is_terminal() { error::not_terminal(); }
+
+	let subcommand = args.subcommand().unwrap();
+
+	//	invoke subcommand function
+	match subcommand.as_deref() {
+		Some("h" | "help")
+			=>	help(&mut args),
+
+		Some("a" | "attach")
+			=>	command::attach(&mut args),
+
+		Some("d" | "detach")
+			=>	command::detach(&mut args),
+
+		Some("has")
+			=>	command::has(&mut args),
+
+		None |
+		Some("l" | "ls" | "list")
+			=>	command::list(),
+
+		Some("n" | "new")
+			=>	command::new(&mut args),
+
+		_
+			=>	error::no_subcommand(subcommand.unwrap())
+	}
+
+	//	re-set TMUX var if we unset it for nest mode
+	if nesting {
+		set_var("TMUX", tmux_var.unwrap());
+	}
 }

--- a/src/state.rs
+++ b/src/state.rs
@ -1,103 +0,0 @@
-use std::{
-	env,
-	path::PathBuf
-};
-
-use pico_args::Arguments;
-
-use crate::{
-	env::{ env_var, REPO_FILE, TMUX },
-	error,
-	flag::Flags,
-	util::{ find, message, MSG_SESSION_NAME }
-};
-
-pub struct State<'a> {
-	pub args: &'a mut Arguments,
-	pub flags: Flags,
-
-	pub session: bool,
-	tmux_var: Option<String>,
-	pub title: Option<String>,
-
-	pub repository: Option<Repository>
-}
-
-impl State<'_> {
-
-	pub fn new(args: &mut Arguments) -> State {
-		let flags = Flags::from(args);
-		let tmux_var = env::var(TMUX).ok();
-		let session = tmux_var.is_some();
-
-		if let Some(ref path) = flags.working_dir { State::set_working_dir(&path); }
-
-		let title = if session { message(MSG_SESSION_NAME) } else { None };
-		let repository = Repository::find();
-
-		State {
-			args,
-			flags,
-
-			session,
-			tmux_var,
-			title,
-
-			repository
-		}
-	}
-
-	pub fn nest_init(&self) {
-		if self.flags.nested {
-			if self.session { env::set_var(TMUX, ""); }		//	nesting & session	=> ok
-			else { error::not_nesting(); }					//	nesting & !session	=> error
-		} else if self.session { error::prevent_nest(); }	//	!nesting & session	=> error
-															//	!nesting & !session	=> ok
-	}
-
-	pub fn nest_deinit(&self) {
-		if self.flags.nested && self.session {
-			env::set_var(TMUX, self.tmux_var.as_ref().unwrap());
-		}
-	}
-
-	pub fn session_enforce(&self, cmd: &'static str) {
-		if !self.session { error::not_in_session(cmd); }
-	}
-
-	fn set_working_dir(path: &str) {
-		let result = env::set_current_dir(path);
-		if result.is_err() {
-			error::working_dir_fail(path);
-		}
-	}
-
-	pub fn target(&mut self) -> Option<String> { self.args.subcommand().unwrap_or(None) }
-	pub fn target_title(&mut self) -> Option<String> {
-		let from_args = self.target();
-		if from_args.is_some() { return from_args; }
-		else if let Some(repository) = &self.repository { Some(repository.name.clone()) }
-		else { error::missing_target() }
-	}
-}
-
-
-pub struct Repository {
-	pub path: PathBuf,
-	pub name: String
-}
-
-impl Repository {
-	pub fn find() -> Option<Repository> {
-		let path = find(&env_var(REPO_FILE), env::current_dir().unwrap());
-		if let Some(path) = path {
-			let name = path.file_name().unwrap().to_string_lossy().to_string();
-			let inner = Repository {
-				path,
-				name
-			};
-			Some(inner)
-		} else { None }
-	}
-}
-
--- a/src/util.rs
+++ b/src/util.rs
@ -1,67 +1,29 @@
 use std::{
-	io::{ stdout, IsTerminal },
-	path::PathBuf
+	env::var,
+	process::exit
 };

 use tmux_interface::{
-	Session, StdIO, Tmux,
-
-	commands,
-	variables::session::SessionsCtl
+	Session, Sessions,
+	variables::session::session::SESSION_ALL
 };

-use crate::error;
-
-pub const NULL: Option<StdIO> = Some(StdIO::Null);
-
-pub const MSG_PREVIOUS:		&str	= "#{client_last_session}";
-pub const MSG_SESSION_NAME:	&str	= "#S";
-pub const MSG_SESSION_PATH:	&str	= "#{session_path}";
-pub const MSG_WINDOW_NAME:	&str	= "#{window_name}";
-
-pub fn message(fstr: &str) -> Option<String> {
-	let message = commands::DisplayMessage::new().print().message(fstr);
-
-	let result = Tmux::new().add_command(message).output();
-	if let Ok(output) = result {
-		let text = String::from_utf8(output.0.stdout);
-		if let Ok(title) = text {
-			if title.len() > 0 { Some(title[0..title.len() - 1].to_owned()) }
-			else { None }
-		} else { None }
-	} else { None }
-}
-
 ///	return a Vec of all sessions or None
 pub fn get_sessions() -> Option<Vec<Session>> {
-	let sessions = SessionsCtl::new().get_all();
-	if let Ok(sessions) = sessions {
-		return Some(sessions.0);
-	} else { return None; }
+	let i_sessions = Sessions::get(SESSION_ALL);
+	if i_sessions.is_err() { return None; }
+	let sessions = i_sessions.ok();
+	if sessions.is_none() { return None; }
+
+	Some(sessions.unwrap().0)
 }

-///	check whether a target session exists
-pub fn session_exists<S: Into<String>>(target: S) -> bool {
-	let has_session = commands::HasSession::new()
-		.target_session(target.into());
-	Tmux::new().add_command(has_session)
-		.stderr(NULL)
-		.status()
-		.unwrap()
-		.success()
-}
-
-///	enforce a command is being run in a terminal
-pub fn terminal_enforce() {
-	if !stdout().is_terminal() { error::not_terminal(); }
-}
-
-///	recursively propagate up directories to find a child
-pub fn find(target: &str, path: PathBuf) -> Option<PathBuf> {
-	if path.join(target).exists() { return Some(path); }
-
-	let parent = path.parent();
-	if let Some(parent) = parent { return find(target, parent.to_path_buf()) }
-	else { None }
+///	show the tmux nest text if env var is not unset
+pub fn prevent_nest() {
+	let tmux = var("TMUX").ok();
+	if tmux.is_some() && tmux.unwrap() != "" {
+		println!("Sessions should be nested with care; unset TMUX or use the '-n' flag to allow.");
+		exit(1);
+	}
 }