removed 'no sessions' text from list command with quiet flag set

added working directory flag
error functions now return a never type
2024-09-24 14:08:19 -04:00 · 2024-09-23 09:02:40 -04:00 · 2024-07-24 20:59:48 -04:00 · 2024-07-22 10:18:35 -04:00 · 2024-07-22 10:18:10 -04:00 · 2024-07-22 09:26:33 -04:00
15 changed files with 914 additions and 202 deletions
--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,12 +1,20 @@
 [package]
 name = "remux"
-version = "0.3.1"
+version = "0.4.0"
 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"
--- a/README.md
+++ b/README.md
@ -23,7 +23,6 @@ remux n foo
 #	list sessions
 tmux ls
 remux l
-remux

 #	attach
 tmux a -t foo
@ -48,8 +47,7 @@ tmux swi -t foo
 rmux s foo

 #	cd to session path
-tmux run 'printf "#{session_path}" > /tmp/tmux_path'
-cd `cat /tmp/tmux_path`
+cd `tmux display-mes -p "#{session_path}"`
 cd `rmux p`

 ```
@ -94,6 +92,19 @@ using an AUR package manager such as <a href="https://github.com/Morganamilo/par
 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`.
--- a/bash-completion/remux
+++ b/bash-completion/remux
@ -0,0 +1,19 @@
+_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
@ -0,0 +1,4 @@
+[licenses]
+allow = [ "MIT" ]
+
+
--- a/man/remux.1
+++ b/man/remux.1
@ -0,0 +1,179 @@
+.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
@ -0,0 +1,260 @@
+{
+  "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/session.rs
+++ b/src/command/session.rs
@ -1,52 +1,67 @@
 //!	commands accessible from within a session
-use std::fs::read_to_string;

-use pico_args::Arguments;
 use tmux_interface::{
 	Tmux,
 	commands
 };

-use crate::{ error, flag, util };
+use crate::{
+	error,
+	state::State,
+	util::{
+		self,
+		message,
+		MSG_PREVIOUS, MSG_SESSION_PATH, NULL
+	}
+};

-const TMP_ROOT: &str = "/tmp/remux_path";
+pub fn path(state: &mut State) {
+	state.session_enforce("path");

-pub fn switch(pargs: &mut Arguments) {
+	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
-	util::session_enforce("switch");
+	state.session_enforce("switch");

 	//	consume optional flags
-	let read_only = pargs.contains(flag::READ_ONLY);
-	//TODO: -d flag handling needs to be done manually
+	let read_only = state.flags.read_only;
+	let detach_other = state.flags.detached;

-	let args = pargs.clone().finish();
-	if args.len() < 1 { error::missing_target(); }
-	let target = args.get(0).unwrap().to_string_lossy().to_string();
+	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);
+	switch = switch.target_session(&target);
 	if read_only { switch.read_only = true; }

-	Tmux::new()
-		.add_command(switch)
-		.output().ok();
+	tmux.add_command(switch)
+		.stderr(NULL).output().ok();
 }

-pub fn path() {
-	util::session_enforce("path");
-
-	let exec = commands::Run::new().shell_command("printf '#{session_path}' > ".to_string() + TMP_ROOT);
-	Tmux::new()
-		.add_command(exec)
-		.output().ok();
-
-	if let Ok(text) = read_to_string(TMP_ROOT) {
-		println!("{text}");
-		std::fs::remove_file(TMP_ROOT).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,8 +1,5 @@
 //! globally available tmux commands.
-use std::{
-	ffi::OsString,
-	process::exit
-};
+use std::process::exit;

 use pico_args::{ Arguments, Error };
 use termion::{ color, style };
@ -12,34 +9,35 @@ use tmux_interface::{
 };

 use crate::{
-	env::{ self, env_var },
+	env::{
+		self,
+		env_var,
+		SYMBOL_ATTACH, SYMBOL_CURRENT, SYMBOL_PREV
+	},
 	error,
 	flag,
-	util
+	state::State,
+	util::{
+		self,
+		message,
+		MSG_PREVIOUS, NULL
+	}
 };

-pub fn attach(pargs: &mut Arguments) {
-	//	must be run from terminal
+pub fn attach(state: &mut State) {
 	util::terminal_enforce();
-	//	don't allow unflagged nests
-	util::prevent_nest();
+	state.nest_init();

 	//	consume optional flags
-	let read_only = pargs.contains(flag::READ_ONLY);
-	let detach_other = pargs.contains(flag::DETACH);
+	let read_only = state.flags.read_only;
+	let detach_other = state.flags.detached;

-	let args = pargs.clone().finish();
-	let target: String;
-	let window: Option<&OsString>;
-	if args.len() < 1 {
-		//	missing name will attempt to fall back to repository
-		target = util::repo_fallback();
-		if !util::session_exists(target.clone()) { error::missing_target(); }
-		window = None;
-	} else {
-		target = args.get(0).unwrap().to_string_lossy().to_string();
-		window = args.get(1);
-	}
+	//	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());
@ -54,26 +52,41 @@ pub fn attach(pargs: &mut Arguments) {
 	let select_window: Option<commands::SelectWindow>;
 	if let Some(window) = window {
 		let mut command = commands::SelectWindow::new();
-		command.target_window = Some(window.to_string_lossy());
+		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.output().ok();
+	tmux.stderr(NULL).output().ok();
+
+	state.nest_deinit();
 }

-pub fn detach(pargs: &mut Arguments) {
-	util::terminal_enforce();
-	//	get target or fallback
-	let args = pargs.clone().finish();
-	let target: String;
-	if args.len() < 1 {
-		target = util::repo_fallback();
+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 {
-		target = args.get(0).unwrap().to_string_lossy().to_string();
+				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());
@ -87,18 +100,12 @@ pub fn detach(pargs: &mut Arguments) {
 		.disable_echo().output().ok();
 }

-pub fn has(pargs: &mut Arguments) {
+pub fn has(state: &mut State) {
 	//	consume optional flags
-	let quiet = pargs.contains(flag::QUIET);
+	let quiet = state.flags.quiet;

-	//	get target or fallback
-	let args = pargs.clone().finish();
-	let target: String;
-	if args.len() < 1 {
-		target = util::repo_fallback();
-	} else {
-		target = args.get(0).unwrap().to_string_lossy().to_string();
-	}
+	//	get target
+	let target = state.target_title().unwrap();

 	//	run command
 	let success = util::session_exists(target.clone());
@ -115,67 +122,83 @@ pub fn has(pargs: &mut Arguments) {
 	exit( if success { 0 } else { 1 });
 }

-pub fn list() {
+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 {
-		println!("no sessions");
+		if !state.flags.quiet { println!("no sessions"); }
 		return;
 	}

 	//	get attached session symbol
-	let attach_symbol = env_var(env::ATTACH_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
-	println!("sessions:");
-	for session in sessions.into_iter() {
-		let group = session.group.unwrap_or("[untitled]".to_string());
+	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!(
-			"   {group} ({bold}{blue}{id}{reset}) {bold}{green}{attach}{reset}",
+				" {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
+				reset		= style::Reset,
 			);
+		} else {
+			print!("{name} ");
+		}
 	}
 }

-pub fn new(pargs: &mut Arguments) {
+pub fn new(state: &mut State) {
 	util::terminal_enforce();
-	//	don't allow unflagged nesting
-	util::prevent_nest();

 	//	get optional flags
-	let detached = pargs.contains(flag::DETACH);
-	let target_dir: Result<String, Error> = pargs.value_from_str(flag::TARGET);
+	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);

-	//	get target or fallback
-	let args = pargs.clone().finish();
-	let title: String;
-	let command: Option<&OsString>;
-	if args.len() < 1 {
-		//	attempt repo fallback
-		title = util::repo_fallback();
-		command = None;
-	} else {
-		title = args.get(0).unwrap().to_string_lossy().to_string();
-		command = args.get(1);
-	}
+	//	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.group_name(title);
-	if let Some(command) = command { new.shell_command = Some(command.to_string_lossy()); }
+	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); }

@ -188,6 +211,6 @@ pub fn new(pargs: &mut Arguments) {
 		tmux = tmux.add_command(auto_name);
 	}

-	tmux.output().ok();
+	tmux.stderr(NULL).output().ok();
 }

--- a/src/env.rs
+++ b/src/env.rs
@ -2,12 +2,16 @@ use std::env::var;

 pub type EnvVar = (&'static str, &'static str);

-pub static ATTACH_SYMBOL: EnvVar	= ("REMUX_ATTACH_SYMBOL", "*");
-pub static NEW_WINDOW_NAME: EnvVar	= ("REMUX_NEW_WINDOW", "");
+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())
 }

-pub fn tmux() -> bool { !var("TMUX").unwrap_or("".to_string()).is_empty() }
-
--- a/src/error.rs
+++ b/src/error.rs
@ -1,45 +1,84 @@
 use std::process::exit;

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

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

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

+
 ///	user provided no target; code 4
-pub fn missing_target() {
-	println!("remux: no target provided");
+pub fn missing_target() -> ! {
+	eprintln!("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() {
-	println!("remux: not running from a terminal");
+pub fn not_terminal() -> ! {
+	eprintln!("remux: not running from a terminal");
 	exit(5);
 }

+
 ///	tried to nest while not in a session; code 6
-pub fn not_nesting() {
-	println!("remux: cannot use nesting flag outside a TMUX session");
+pub fn not_nesting() -> ! {
+	eprintln!("remux: inappropriate nesting flag (-n); not in a 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) {
-	println!("remux: '{cmd}' must be run from within a session");
+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,4 +1,6 @@

+use pico_args::Arguments;
+
 type Flag = [&'static str;2];

 pub static DETACH: Flag			= [ "-d", "--detach" ];
@ -8,4 +10,47 @@ 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
@ -13,7 +13,7 @@ println!("remux v{VERSION}
 Valerie Wolfe <sleeplessval@gmail.com>
 A command wrapper for tmux written in Rust.

-usage: remux <command> [<args>]
+usage: remux [command] [<args>]

 commands:
   help       Show help text for remux, a command, or a help topic.
@ -25,6 +25,7 @@ commands:

   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.

@ -101,7 +102,7 @@ flags:
   -n, --nest             Create the session inside another session.
   -t, --target <dir>     Sets the target directory for the new session."),

-		Some("root")
+		Some("p" | "path")
 		=>
 println!("remux path
 Print the session path (#{{session_path}}) to standard output.
@ -126,6 +127,16 @@ 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")
@ -137,10 +148,15 @@ REMUX_ATTACH_SYMBOL
   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: ''"),
+   Default: (unset)"),

 		//	not found
 		_	=>	error::no_help(topic.unwrap())
--- a/src/main.rs
+++ b/src/main.rs
@ -1,4 +1,3 @@
-use std::env::{ set_var, var };

 use pico_args::Arguments;

@ -7,9 +6,11 @@ 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");

@ -28,51 +29,44 @@ fn main() {
 		return;
 	}

-	let nesting = args.contains(flag::NEST);
-	let tmux_var = var("TMUX").ok();
-	if nesting {
-		if tmux_var.is_none() {
-			error::not_nesting();
-		}
-		set_var("TMUX", "");
-	}
+	let mut state = State::new(&mut args);

-	let subcommand = args.subcommand().unwrap();
+	let target = state.target();

 	//	invoke subcommand function
-	match subcommand.as_deref() {
+	match target.as_deref() {
 		Some("help")
 			=>	help(&mut args),
+		None
+			=>	command::share::context_action(&mut state),

 		Some("a" | "attach")
-			=>	command::share::attach(&mut args),
+			=>	command::share::attach(&mut state),

 		Some("d" | "detach")
-			=>	command::share::detach(&mut args),
+			=>	command::share::detach(&mut state),

 		Some("h" | "has")
-			=>	command::share::has(&mut args),
+			=>	command::share::has(&mut state),

-		None |
 		Some("l" | "ls" | "list")
-			=>	command::share::list(),
+			=>	command::share::list(&mut state),

 		Some("n" | "new")
-			=>	command::share::new(&mut args),
+			=>	command::share::new(&mut state),

 		Some("p" | "path")
-			=>	command::session::path(),
+			=>	command::session::path(&mut state),

 		Some("s" | "switch")
-			=>	command::session::switch(&mut args),
+			=>	command::session::switch(&mut state),
+
+		Some("t" | "title" | "which")
+			=>	command::session::title(state),

 		_
-			=>	error::no_subcommand(subcommand.unwrap())
+			=>	error::no_subcommand(target.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
@ -0,0 +1,103 @@
+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,21 +1,36 @@
 use std::{
-	env::current_dir,
 	io::{ stdout, IsTerminal },
-	path::PathBuf,
-	process::exit
+	path::PathBuf
 };

 use tmux_interface::{
-	Session, Tmux,
+	Session, StdIO, Tmux,

 	commands,
 	variables::session::SessionsCtl
 };

-use crate::{
-	env,
-	error
-};
+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>> {
@ -25,24 +40,12 @@ pub fn get_sessions() -> Option<Vec<Session>> {
 	} else { return None; }
 }

-///	show the tmux nest text if env var is not unset
-pub fn prevent_nest() {
-	if env::tmux() {
-		println!("To nest sessions, use the -n flag.");
-		exit(6);
-	}
-}
-
-///	enforce a command is being used in-session
-pub fn session_enforce(cmd: &'static str) {
-	if !env::tmux() { error::not_in_session(cmd); }
-}
-
 ///	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()
@ -53,23 +56,12 @@ pub fn terminal_enforce() {
 	if !stdout().is_terminal() { error::not_terminal(); }
 }

-///	attempt to return the repo name or exit
-pub fn repo_fallback() -> String {
-	let repo = repo_root(current_dir().unwrap());
-	if repo.is_none() { error::missing_target(); }
+///	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 target = repo.unwrap().file_name().unwrap().to_string_lossy().to_string();
-	target
-}
-
-///	recursively attempt to find a git root directory
-pub fn repo_root(path: PathBuf) -> Option<PathBuf> {
-	//	if .git dir is found, return
-	if path.join(".git").exists() { return Some(path); }
-
-	//	otherwise, attempt to traverse
 	let parent = path.parent();
-	if let Some(parent) = parent { repo_root(parent.to_path_buf()) }
+	if let Some(parent) = parent { return find(target, parent.to_path_buf()) }
 	else { None }
 }
Author	SHA1	Message	Date
Valerie	4f76590930	removed 'no sessions' text from list command with quiet flag set	2024-09-24 14:08:19 -04:00
Valerie	d3a408ad33	added working directory flag	2024-09-23 09:02:40 -04:00
Valerie	8449ae00d6	error functions now return a never type	2024-07-24 20:59:48 -04:00
Valerie	ff30bc1052	minor 'list' optimization	2024-07-22 10:18:35 -04:00
Valerie	8e2826b110	message helper now handles empty responses more gracefully	2024-07-22 10:18:10 -04:00
Valerie	0fe3906578	'switch' command now supports detach flag, and updated manual documentation for 'switch'	2024-07-22 09:26:33 -04:00
Valerie	fdf3114c04	'list' command now shows a symbol for the previous session	2024-07-17 11:30:50 -04:00
Valerie	8ad16ad825	'switch' now handles empty case correctly	2024-07-17 11:21:05 -04:00
Valerie	a9a73314af	'switch' command now defaults to previous session if present	2024-07-17 11:07:14 -04:00
Valerie	af33e82415	renamed bash completion folder to be more appropriate	2024-07-17 09:24:31 -04:00
Valerie	eaf72847b1	updated README	2024-07-17 09:23:34 -04:00
Valerie	beb880ed43	Merge branch 'repo-var' into completion	2024-07-17 09:17:35 -04:00
Valerie	449c460bbb	repository search now tries to match the filename set by the REMUX_REPO_NAME environment variable	2024-07-17 09:15:11 -04:00
Valerie	1b51633d4f	added search and quiet mode to 'list' command and wrote a completion function	2024-07-16 11:46:56 -04:00
Valerie	b7b893d55c	errors now print to stderr instead of stdout	2024-07-12 10:48:03 -04:00
Valerie	cdc68986fa	inner tmux errors are now hidden	2024-07-06 21:10:39 -04:00
Valerie	1acc7aeb7b	updated README	2024-07-06 20:48:45 -04:00
Valerie	449921656c	added man instructions to README	2024-07-06 18:33:28 -04:00
Valerie	638fce2331	minor man correction	2024-07-06 17:01:20 -04:00
Valerie	b93d814f6f	version bump	2024-07-01 12:05:29 -04:00
Valerie	b24778113a	'new' now fails on duplicate names, reduced code reuse	2024-07-01 11:52:33 -04:00
Valerie	21bd6f40ca	created manual	2024-07-01 09:54:10 -04:00
Valerie	1f143f00ad	'which' command is now 'title'	2024-07-01 09:53:52 -04:00
Valerie	e930af1027	list command now shows a symbol in front of the current session	2024-07-01 09:12:38 -04:00
Valerie	97f546a69c	fixed 'add' command enforcing nest flag on detached sessions	2024-07-01 08:50:23 -04:00
Valerie	44bad997cb	context action now passes flags	2024-06-25 14:05:28 -04:00
Valerie	441f1d3ef0	removed unused module reference	2024-06-24 17:19:01 -04:00
Valerie	0232a9c650	updated README and help text	2024-06-24 17:17:40 -04:00
Valerie	ace9627b79	major refactor; parameters are handled by a state struct	2024-06-24 16:32:41 -04:00
Valerie	a915bfd9c5	updated README and help text	2024-06-18 12:02:47 -04:00
Valerie	ac97336f13	added contextual action as default command	2024-06-18 11:57:08 -04:00
Valerie	222f929fd4	merged in changes from 'switch' branch	2024-06-17 13:54:05 -04:00
Valerie	307ff23049	updated Cargo.toml	2024-03-14 17:27:12 -04:00
Valerie	3e4346bd1d	version bump and added data for auditing tools	2024-03-14 16:42:11 -04:00
Valerie	7f5ad2fd1b	fixed 'new' command setting group name instead of session name	2024-03-14 16:37:00 -04:00
Valerie	8b00f58fde	updated cargo-aur metadata	2024-03-06 16:49:25 -05:00
Valerie	c776b63994	Merge remote-tracking branch 'refs/remotes/origin/main'	2024-03-06 16:44:54 -05:00
Valerie	640381820d	added cargo-aur metadata	2024-03-04 10:53:10 -05:00