dkdc-sh 0.1.0__tar.gz

dkdc_sh-0.1.0/Cargo.toml

@@ -0,0 +1,9 @@
+[workspace]
+resolver = "2"
+members = ["crates/sh-core"]
+exclude = ["crates/sh-py"]
+
+[profile.release]
+lto = true
+strip = true
+codegen-units = 1

dkdc_sh-0.1.0/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2026 Cody
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

dkdc_sh-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: dkdc-sh
+Version: 0.1.0
+License-File: LICENSE
+Summary: Shell utilities for tmux, git, and command management
+Author-email: Cody <cody@dkdc.io>
+License-Expression: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# sh
+
+Shell utilities for tmux, git, and command management.
+
+## Install
+
+```bash
+cargo add dkdc-sh
+```
+
+```bash
+uv add dkdc-sh
+```
+
+## Usage
+
+### Rust
+
+```rust
+use dkdc_sh::{which, require, run, tmux, git};
+
+// Command checking
+if which("tmux").is_some() { /* ... */ }
+require("git")?;
+
+// Run arbitrary commands
+let output = run("echo", &["hello"])?;
+
+// Tmux session management
+tmux::new_session("my-service", "python server.py")?;
+tmux::send_keys("my-service", "reload")?;
+let logs = tmux::capture_pane("my-service", Some(50))?;
+tmux::kill_session("my-service")?;
+
+// Git operations
+git::clone_shallow("https://github.com/org/repo.git", &dest, "main")?;
+git::checkout_new_branch(&repo_dir, "feature/branch")?;
+git::config_set(&repo_dir, "user.email", "bot@example.com")?;
+```
+
+### Python
+
+```python
+import dkdc_sh
+
+# Command checking
+path = dkdc_sh.which("tmux")
+dkdc_sh.require("git")
+
+# Run commands
+output = dkdc_sh.run("echo", ["hello"])
+
+# Tmux
+dkdc_sh.tmux_new_session("my-service", "python server.py")
+logs = dkdc_sh.tmux_capture_pane("my-service", lines=50)
+dkdc_sh.tmux_kill_session("my-service")
+
+# Git
+dkdc_sh.git_clone_shallow("https://github.com/org/repo.git", "./dest", "main")
+dkdc_sh.git_checkout_new_branch("./repo", "feature/branch")
+```
+

dkdc_sh-0.1.0/README.md

@@ -0,0 +1,61 @@
+# sh
+
+Shell utilities for tmux, git, and command management.
+
+## Install
+
+```bash
+cargo add dkdc-sh
+```
+
+```bash
+uv add dkdc-sh
+```
+
+## Usage
+
+### Rust
+
+```rust
+use dkdc_sh::{which, require, run, tmux, git};
+
+// Command checking
+if which("tmux").is_some() { /* ... */ }
+require("git")?;
+
+// Run arbitrary commands
+let output = run("echo", &["hello"])?;
+
+// Tmux session management
+tmux::new_session("my-service", "python server.py")?;
+tmux::send_keys("my-service", "reload")?;
+let logs = tmux::capture_pane("my-service", Some(50))?;
+tmux::kill_session("my-service")?;
+
+// Git operations
+git::clone_shallow("https://github.com/org/repo.git", &dest, "main")?;
+git::checkout_new_branch(&repo_dir, "feature/branch")?;
+git::config_set(&repo_dir, "user.email", "bot@example.com")?;
+```
+
+### Python
+
+```python
+import dkdc_sh
+
+# Command checking
+path = dkdc_sh.which("tmux")
+dkdc_sh.require("git")
+
+# Run commands
+output = dkdc_sh.run("echo", ["hello"])
+
+# Tmux
+dkdc_sh.tmux_new_session("my-service", "python server.py")
+logs = dkdc_sh.tmux_capture_pane("my-service", lines=50)
+dkdc_sh.tmux_kill_session("my-service")
+
+# Git
+dkdc_sh.git_clone_shallow("https://github.com/org/repo.git", "./dest", "main")
+dkdc_sh.git_checkout_new_branch("./repo", "feature/branch")
+```

dkdc_sh-0.1.0/crates/sh-core/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "dkdc-sh"
+version = "0.1.0"
+edition = "2024"
+authors = ["Cody <cody@dkdc.io>"]
+description = "Shell utilities for tmux, git, and command management"
+repository = "https://github.com/dkdc-io/sh"
+license = "MIT"
+readme = "README.md"
+
+[lib]
+name = "dkdc_sh"
+path = "src/lib.rs"
+
+[dependencies]
+which = "7"

dkdc_sh-0.1.0/crates/sh-core/README.md

@@ -0,0 +1,61 @@
+# sh
+
+Shell utilities for tmux, git, and command management.
+
+## Install
+
+```bash
+cargo add dkdc-sh
+```
+
+```bash
+uv add dkdc-sh
+```
+
+## Usage
+
+### Rust
+
+```rust
+use dkdc_sh::{which, require, run, tmux, git};
+
+// Command checking
+if which("tmux").is_some() { /* ... */ }
+require("git")?;
+
+// Run arbitrary commands
+let output = run("echo", &["hello"])?;
+
+// Tmux session management
+tmux::new_session("my-service", "python server.py")?;
+tmux::send_keys("my-service", "reload")?;
+let logs = tmux::capture_pane("my-service", Some(50))?;
+tmux::kill_session("my-service")?;
+
+// Git operations
+git::clone_shallow("https://github.com/org/repo.git", &dest, "main")?;
+git::checkout_new_branch(&repo_dir, "feature/branch")?;
+git::config_set(&repo_dir, "user.email", "bot@example.com")?;
+```
+
+### Python
+
+```python
+import dkdc_sh
+
+# Command checking
+path = dkdc_sh.which("tmux")
+dkdc_sh.require("git")
+
+# Run commands
+output = dkdc_sh.run("echo", ["hello"])
+
+# Tmux
+dkdc_sh.tmux_new_session("my-service", "python server.py")
+logs = dkdc_sh.tmux_capture_pane("my-service", lines=50)
+dkdc_sh.tmux_kill_session("my-service")
+
+# Git
+dkdc_sh.git_clone_shallow("https://github.com/org/repo.git", "./dest", "main")
+dkdc_sh.git_checkout_new_branch("./repo", "feature/branch")
+```

dkdc_sh-0.1.0/crates/sh-core/src/git.rs

@@ -0,0 +1,124 @@
+//! Git command abstractions (sync).
+
+use std::path::Path;
+use std::process::Command;
+
+use crate::{Error, require};
+
+/// Run a git command in a directory and return stdout.
+pub fn cmd(dir: &Path, args: &[&str]) -> Result<String, Error> {
+    cmd_with_env(dir, args, &[])
+}
+
+/// Run a git command with extra environment variables.
+///
+/// When `GIT_ASKPASS` is present in `env`, credential helpers are disabled
+/// to prevent interception by system keychains.
+pub fn cmd_with_env(dir: &Path, args: &[&str], env: &[(&str, &str)]) -> Result<String, Error> {
+    require("git")?;
+
+    let has_askpass = env.iter().any(|(k, _)| *k == "GIT_ASKPASS");
+
+    let mut command = Command::new("git");
+    if has_askpass {
+        command.args(["-c", "credential.helper="]);
+    }
+    command.args(args).current_dir(dir);
+    for (k, v) in env {
+        command.env(k, v);
+    }
+    let output = command.output()?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        return Err(Error::CommandFailed {
+            cmd: format!("git {}", args.first().unwrap_or(&"")),
+            detail: stderr,
+        });
+    }
+
+    Ok(String::from_utf8_lossy(&output.stdout).to_string())
+}
+
+/// Shallow-clone a repo (single branch, depth 1).
+pub fn clone_shallow(url: &str, dest: &Path, branch: &str) -> Result<(), Error> {
+    clone_shallow_with_env(url, dest, branch, &[])
+}
+
+/// Shallow-clone a repo with extra environment variables.
+pub fn clone_shallow_with_env(
+    url: &str,
+    dest: &Path,
+    branch: &str,
+    env: &[(&str, &str)],
+) -> Result<(), Error> {
+    require("git")?;
+
+    let has_askpass = env.iter().any(|(k, _)| *k == "GIT_ASKPASS");
+
+    let mut command = Command::new("git");
+    if has_askpass {
+        command.args(["-c", "credential.helper="]);
+    }
+    command.args([
+        "clone",
+        "--depth",
+        "1",
+        "--branch",
+        branch,
+        url,
+        &dest.to_string_lossy(),
+    ]);
+    for (k, v) in env {
+        command.env(k, v);
+    }
+    let output = command.output()?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        return Err(Error::CommandFailed {
+            cmd: "git clone".to_string(),
+            detail: stderr,
+        });
+    }
+
+    Ok(())
+}
+
+/// Clone from a local repo directory (fast, shares objects via hardlinks).
+pub fn clone_local(source: &Path, dest: &Path, branch: &str) -> Result<(), Error> {
+    require("git")?;
+
+    let output = Command::new("git")
+        .args([
+            "clone",
+            "--branch",
+            branch,
+            "--single-branch",
+            &source.to_string_lossy(),
+            &dest.to_string_lossy(),
+        ])
+        .output()?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        return Err(Error::CommandFailed {
+            cmd: "git clone (local)".to_string(),
+            detail: stderr,
+        });
+    }
+
+    Ok(())
+}
+
+/// Create and switch to a new branch.
+pub fn checkout_new_branch(dir: &Path, branch: &str) -> Result<(), Error> {
+    cmd(dir, &["checkout", "-b", branch])?;
+    Ok(())
+}
+
+/// Set a git config key in a repo.
+pub fn config_set(dir: &Path, key: &str, value: &str) -> Result<(), Error> {
+    cmd(dir, &["config", key, value])?;
+    Ok(())
+}

dkdc_sh-0.1.0/crates/sh-core/src/lib.rs

@@ -0,0 +1,126 @@
+//! Shell utilities for tmux, git, and command management.
+//!
+//! Minimal, synchronous shell abstractions. No async runtime required.
+
+use std::fmt;
+use std::path::PathBuf;
+use std::process::Command;
+
+pub mod git;
+pub mod tmux;
+
+/// Shell operation errors.
+#[derive(Debug)]
+pub enum Error {
+    CommandNotFound(String),
+    CommandFailed { cmd: String, detail: String },
+    Tmux(String),
+    Io(std::io::Error),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::CommandNotFound(cmd) => write!(f, "command not found: {cmd}"),
+            Error::CommandFailed { cmd, detail } => write!(f, "command failed: {cmd} — {detail}"),
+            Error::Tmux(msg) => write!(f, "tmux error: {msg}"),
+            Error::Io(err) => write!(f, "io error: {err}"),
+        }
+    }
+}
+
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Error::Io(err) => Some(err),
+            _ => None,
+        }
+    }
+}
+
+impl From<std::io::Error> for Error {
+    fn from(err: std::io::Error) -> Self {
+        Error::Io(err)
+    }
+}
+
+/// Check if a command exists in PATH.
+pub fn which(cmd: &str) -> Option<PathBuf> {
+    ::which::which(cmd).ok()
+}
+
+/// Require a command to exist, returning an error if not found.
+pub fn require(cmd: &str) -> Result<PathBuf, Error> {
+    ::which::which(cmd).map_err(|_| Error::CommandNotFound(cmd.to_string()))
+}
+
+/// Run a command and return its stdout.
+pub fn run(program: &str, args: &[&str]) -> Result<String, Error> {
+    run_with_env(program, args, &[])
+}
+
+/// Run a command with extra environment variables and return its stdout.
+pub fn run_with_env(program: &str, args: &[&str], env: &[(&str, &str)]) -> Result<String, Error> {
+    require(program)?;
+
+    let mut command = Command::new(program);
+    command.args(args);
+    for (k, v) in env {
+        command.env(k, v);
+    }
+    let output = command.output()?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        return Err(Error::CommandFailed {
+            cmd: format!("{program} {}", args.first().unwrap_or(&"")),
+            detail: stderr,
+        });
+    }
+
+    Ok(String::from_utf8_lossy(&output.stdout).to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_which_exists() {
+        assert!(which("ls").is_some());
+    }
+
+    #[test]
+    fn test_which_not_exists() {
+        assert!(which("nonexistent_command_12345").is_none());
+    }
+
+    #[test]
+    fn test_require_exists() {
+        assert!(require("ls").is_ok());
+    }
+
+    #[test]
+    fn test_require_not_exists() {
+        let result = require("nonexistent_command_12345");
+        assert!(result.is_err());
+        assert!(matches!(result, Err(Error::CommandNotFound(_))));
+    }
+
+    #[test]
+    fn test_run() {
+        let output = run("echo", &["hello"]).unwrap();
+        assert_eq!(output.trim(), "hello");
+    }
+
+    #[test]
+    fn test_run_not_found() {
+        let result = run("nonexistent_command_12345", &[]);
+        assert!(matches!(result, Err(Error::CommandNotFound(_))));
+    }
+
+    #[test]
+    fn test_has_session_nonexistent() {
+        assert!(!tmux::has_session("dkdc_test_nonexistent_12345"));
+    }
+}

dkdc_sh-0.1.0/crates/sh-core/src/tmux.rs

@@ -0,0 +1,136 @@
+//! Tmux session management.
+
+use std::process::{Command, Stdio};
+
+use crate::{Error, require};
+
+/// Check if a tmux session exists.
+pub fn has_session(name: &str) -> bool {
+    Command::new("tmux")
+        .args(["has-session", "-t", name])
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()
+        .map(|s| s.success())
+        .unwrap_or(false)
+}
+
+/// Create a new detached tmux session and run a command in it.
+///
+/// The session is created with `remain-on-exit on` so it persists
+/// even after the command exits.
+pub fn new_session(name: &str, cmd: &str) -> Result<(), Error> {
+    require("tmux")?;
+
+    if has_session(name) {
+        return Err(Error::Tmux(format!("session '{name}' already exists")));
+    }
+
+    let status = Command::new("tmux")
+        .args(["new-session", "-d", "-s", name])
+        .status()?;
+
+    if !status.success() {
+        return Err(Error::Tmux(format!("failed to create session '{name}'")));
+    }
+
+    let status = Command::new("tmux")
+        .args(["set-option", "-t", name, "remain-on-exit", "on"])
+        .status()?;
+
+    if !status.success() {
+        return Err(Error::Tmux(
+            "failed to set remain-on-exit option".to_string(),
+        ));
+    }
+
+    send_keys(name, cmd)?;
+
+    Ok(())
+}
+
+/// Kill a tmux session. Idempotent — returns Ok if already gone.
+pub fn kill_session(name: &str) -> Result<(), Error> {
+    require("tmux")?;
+
+    if !has_session(name) {
+        return Ok(());
+    }
+
+    let status = Command::new("tmux")
+        .args(["kill-session", "-t", name])
+        .status()?;
+
+    if !status.success() {
+        return Err(Error::Tmux(format!("failed to kill session '{name}'")));
+    }
+
+    Ok(())
+}
+
+/// Attach to a tmux session (takes over the terminal).
+pub fn attach(name: &str) -> Result<(), Error> {
+    require("tmux")?;
+
+    if !has_session(name) {
+        return Err(Error::Tmux(format!("session '{name}' does not exist")));
+    }
+
+    let status = Command::new("tmux").args(["attach", "-t", name]).status()?;
+
+    if !status.success() {
+        return Err(Error::Tmux(format!("failed to attach to session '{name}'")));
+    }
+
+    Ok(())
+}
+
+/// Send keys followed by Enter to a tmux session.
+pub fn send_keys(name: &str, keys: &str) -> Result<(), Error> {
+    require("tmux")?;
+
+    if !has_session(name) {
+        return Err(Error::Tmux(format!("session '{name}' does not exist")));
+    }
+
+    let status = Command::new("tmux")
+        .args(["send-keys", "-t", name, keys, "Enter"])
+        .status()?;
+
+    if !status.success() {
+        return Err(Error::Tmux(format!(
+            "failed to send keys to session '{name}'"
+        )));
+    }
+
+    Ok(())
+}
+
+/// Capture output from a tmux pane.
+///
+/// Returns the last `lines` lines of output, or all visible lines if None.
+pub fn capture_pane(name: &str, lines: Option<usize>) -> Result<String, Error> {
+    require("tmux")?;
+
+    if !has_session(name) {
+        return Err(Error::Tmux(format!("session '{name}' does not exist")));
+    }
+
+    let mut args = vec!["capture-pane", "-t", name, "-p"];
+
+    let start_arg;
+    if let Some(n) = lines {
+        start_arg = format!("-{n}");
+        args.extend(["-S", &start_arg]);
+    }
+
+    let output = Command::new("tmux").args(&args).output()?;
+
+    if !output.status.success() {
+        return Err(Error::Tmux(format!(
+            "failed to capture pane from session '{name}'"
+        )));
+    }
+
+    Ok(String::from_utf8_lossy(&output.stdout).to_string())
+}

dkdc_sh-0.1.0/crates/sh-py/Cargo.lock

@@ -0,0 +1,221 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "bitflags"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+
+[[package]]
+name = "dkdc-sh"
+version = "0.1.0"
+dependencies = [
+ "which",
+]
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "env_home"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7f84e12ccf0a7ddc17a6c41c93326024c42920d7ee630d04950e6926645c0fe"
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "libc"
+version = "0.2.184"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48f5d2a454e16a5ea0f4ced81bd44e4cfc7bd3a507b61887c99fd3538b28e4af"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.28.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91fd8e38a3b50ed1167fb981cd6fd60147e091784c427b8f7183a7ee32c31c12"
+dependencies = [
+ "libc",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.28.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e368e7ddfdeb98c9bca7f8383be1648fd84ab466bf2bc015e94008db6d35611e"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.28.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f29e10af80b1f7ccaf7f69eace800a03ecd13e883acfacc1e5d0988605f651e"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.28.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df6e520eff47c45997d2fc7dd8214b25dd1310918bbb2642156ef66a67f29813"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.28.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4cdc218d835738f81c2338f822078af45b4afdf8b2e33cbb5916f108b813acb"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys",
+]
+
+[[package]]
+name = "sh-py"
+version = "0.1.0"
+dependencies = [
+ "dkdc-sh",
+ "pyo3",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "which"
+version = "7.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d643ce3fd3e5b54854602a080f34fb10ab75e0b813ee32d00ca2b44fa74762"
+dependencies = [
+ "either",
+ "env_home",
+ "rustix",
+ "winsafe",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "winsafe"
+version = "0.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904"

dkdc_sh-0.1.0/crates/sh-py/Cargo.toml

@@ -0,0 +1,16 @@
+[workspace]
+
+[package]
+name = "sh-py"
+version = "0.1.0"
+edition = "2024"
+authors = ["Cody <cody@dkdc.io>"]
+license = "MIT"
+
+[lib]
+name = "_core"
+crate-type = ["cdylib"]
+
+[dependencies]
+dkdc-sh = { path = "../sh-core" }
+pyo3 = { version = "0.28", features = ["extension-module", "abi3-py311"] }

dkdc_sh-0.1.0/crates/sh-py/src/lib.rs

@@ -0,0 +1,146 @@
+use std::path::PathBuf;
+
+use pyo3::exceptions::PyRuntimeError;
+use pyo3::prelude::*;
+
+fn to_py_err(e: dkdc_sh::Error) -> PyErr {
+    PyErr::new::<PyRuntimeError, _>(e.to_string())
+}
+
+// -- Root functions -----------------------------------------------------------
+
+#[pyfunction]
+fn which(cmd: &str) -> Option<String> {
+    dkdc_sh::which(cmd).map(|p| p.to_string_lossy().into_owned())
+}
+
+#[pyfunction]
+fn require(cmd: &str) -> PyResult<String> {
+    dkdc_sh::require(cmd)
+        .map(|p| p.to_string_lossy().into_owned())
+        .map_err(to_py_err)
+}
+
+#[pyfunction]
+#[pyo3(signature = (program, args, env=None))]
+fn run(program: &str, args: Vec<String>, env: Option<Vec<(String, String)>>) -> PyResult<String> {
+    let args_ref: Vec<&str> = args.iter().map(|s| s.as_str()).collect();
+    match env {
+        Some(env_pairs) => {
+            let env_ref: Vec<(&str, &str)> = env_pairs
+                .iter()
+                .map(|(k, v)| (k.as_str(), v.as_str()))
+                .collect();
+            dkdc_sh::run_with_env(program, &args_ref, &env_ref).map_err(to_py_err)
+        }
+        None => dkdc_sh::run(program, &args_ref).map_err(to_py_err),
+    }
+}
+
+// -- Tmux functions -----------------------------------------------------------
+
+#[pyfunction]
+fn tmux_has_session(name: &str) -> bool {
+    dkdc_sh::tmux::has_session(name)
+}
+
+#[pyfunction]
+fn tmux_new_session(name: &str, cmd: &str) -> PyResult<()> {
+    dkdc_sh::tmux::new_session(name, cmd).map_err(to_py_err)
+}
+
+#[pyfunction]
+fn tmux_kill_session(name: &str) -> PyResult<()> {
+    dkdc_sh::tmux::kill_session(name).map_err(to_py_err)
+}
+
+#[pyfunction]
+fn tmux_attach(name: &str) -> PyResult<()> {
+    dkdc_sh::tmux::attach(name).map_err(to_py_err)
+}
+
+#[pyfunction]
+fn tmux_send_keys(name: &str, keys: &str) -> PyResult<()> {
+    dkdc_sh::tmux::send_keys(name, keys).map_err(to_py_err)
+}
+
+#[pyfunction]
+#[pyo3(signature = (name, lines=None))]
+fn tmux_capture_pane(name: &str, lines: Option<usize>) -> PyResult<String> {
+    dkdc_sh::tmux::capture_pane(name, lines).map_err(to_py_err)
+}
+
+// -- Git functions ------------------------------------------------------------
+
+#[pyfunction]
+fn git_cmd(dir: &str, args: Vec<String>) -> PyResult<String> {
+    let args_ref: Vec<&str> = args.iter().map(|s| s.as_str()).collect();
+    dkdc_sh::git::cmd(&PathBuf::from(dir), &args_ref).map_err(to_py_err)
+}
+
+#[pyfunction]
+#[pyo3(signature = (dir, args, env=None))]
+fn git_cmd_with_env(
+    dir: &str,
+    args: Vec<String>,
+    env: Option<Vec<(String, String)>>,
+) -> PyResult<String> {
+    let args_ref: Vec<&str> = args.iter().map(|s| s.as_str()).collect();
+    let env_pairs = env.unwrap_or_default();
+    let env_ref: Vec<(&str, &str)> = env_pairs
+        .iter()
+        .map(|(k, v)| (k.as_str(), v.as_str()))
+        .collect();
+    dkdc_sh::git::cmd_with_env(&PathBuf::from(dir), &args_ref, &env_ref).map_err(to_py_err)
+}
+
+#[pyfunction]
+fn git_clone_shallow(url: &str, dest: &str, branch: &str) -> PyResult<()> {
+    dkdc_sh::git::clone_shallow(url, &PathBuf::from(dest), branch).map_err(to_py_err)
+}
+
+#[pyfunction]
+fn git_clone_local(source: &str, dest: &str, branch: &str) -> PyResult<()> {
+    dkdc_sh::git::clone_local(&PathBuf::from(source), &PathBuf::from(dest), branch)
+        .map_err(to_py_err)
+}
+
+#[pyfunction]
+fn git_checkout_new_branch(dir: &str, branch: &str) -> PyResult<()> {
+    dkdc_sh::git::checkout_new_branch(&PathBuf::from(dir), branch).map_err(to_py_err)
+}
+
+#[pyfunction]
+fn git_config_set(dir: &str, key: &str, value: &str) -> PyResult<()> {
+    dkdc_sh::git::config_set(&PathBuf::from(dir), key, value).map_err(to_py_err)
+}
+
+// -- Module -------------------------------------------------------------------
+
+#[pymodule]
+mod core {
+    use super::*;
+
+    #[pymodule_init]
+    fn module_init(m: &Bound<'_, PyModule>) -> PyResult<()> {
+        // Root
+        m.add_function(wrap_pyfunction!(which, m)?)?;
+        m.add_function(wrap_pyfunction!(require, m)?)?;
+        m.add_function(wrap_pyfunction!(run, m)?)?;
+        // Tmux
+        m.add_function(wrap_pyfunction!(tmux_has_session, m)?)?;
+        m.add_function(wrap_pyfunction!(tmux_new_session, m)?)?;
+        m.add_function(wrap_pyfunction!(tmux_kill_session, m)?)?;
+        m.add_function(wrap_pyfunction!(tmux_attach, m)?)?;
+        m.add_function(wrap_pyfunction!(tmux_send_keys, m)?)?;
+        m.add_function(wrap_pyfunction!(tmux_capture_pane, m)?)?;
+        // Git
+        m.add_function(wrap_pyfunction!(git_cmd, m)?)?;
+        m.add_function(wrap_pyfunction!(git_cmd_with_env, m)?)?;
+        m.add_function(wrap_pyfunction!(git_clone_shallow, m)?)?;
+        m.add_function(wrap_pyfunction!(git_clone_local, m)?)?;
+        m.add_function(wrap_pyfunction!(git_checkout_new_branch, m)?)?;
+        m.add_function(wrap_pyfunction!(git_config_set, m)?)?;
+        Ok(())
+    }
+}

dkdc_sh-0.1.0/py/dkdc_sh/__init__.py

@@ -0,0 +1,35 @@
+from dkdc_sh.core import (
+    git_checkout_new_branch,
+    git_clone_local,
+    git_clone_shallow,
+    git_cmd,
+    git_cmd_with_env,
+    git_config_set,
+    require,
+    run,
+    tmux_attach,
+    tmux_capture_pane,
+    tmux_has_session,
+    tmux_kill_session,
+    tmux_new_session,
+    tmux_send_keys,
+    which,
+)
+
+__all__ = [
+    "which",
+    "require",
+    "run",
+    "tmux_has_session",
+    "tmux_new_session",
+    "tmux_kill_session",
+    "tmux_attach",
+    "tmux_send_keys",
+    "tmux_capture_pane",
+    "git_cmd",
+    "git_cmd_with_env",
+    "git_clone_shallow",
+    "git_clone_local",
+    "git_checkout_new_branch",
+    "git_config_set",
+]

dkdc_sh-0.1.0/py/dkdc_sh/core.pyi

@@ -0,0 +1,67 @@
+def which(cmd: str) -> str | None:
+    """Check if a command exists in PATH. Returns the path or None."""
+    ...
+
+def require(cmd: str) -> str:
+    """Require a command to exist. Returns the path or raises RuntimeError."""
+    ...
+
+def run(
+    program: str,
+    args: list[str],
+    env: list[tuple[str, str]] | None = None,
+) -> str:
+    """Run a command and return its stdout."""
+    ...
+
+def tmux_has_session(name: str) -> bool:
+    """Check if a tmux session exists."""
+    ...
+
+def tmux_new_session(name: str, cmd: str) -> None:
+    """Create a new detached tmux session and run a command in it."""
+    ...
+
+def tmux_kill_session(name: str) -> None:
+    """Kill a tmux session. Idempotent."""
+    ...
+
+def tmux_attach(name: str) -> None:
+    """Attach to a tmux session (takes over the terminal)."""
+    ...
+
+def tmux_send_keys(name: str, keys: str) -> None:
+    """Send keys followed by Enter to a tmux session."""
+    ...
+
+def tmux_capture_pane(name: str, lines: int | None = None) -> str:
+    """Capture output from a tmux pane."""
+    ...
+
+def git_cmd(dir: str, args: list[str]) -> str:
+    """Run a git command in a directory and return stdout."""
+    ...
+
+def git_cmd_with_env(
+    dir: str,
+    args: list[str],
+    env: list[tuple[str, str]] | None = None,
+) -> str:
+    """Run a git command with extra environment variables."""
+    ...
+
+def git_clone_shallow(url: str, dest: str, branch: str) -> None:
+    """Shallow-clone a repo (single branch, depth 1)."""
+    ...
+
+def git_clone_local(source: str, dest: str, branch: str) -> None:
+    """Clone from a local repo directory (fast, shares objects via hardlinks)."""
+    ...
+
+def git_checkout_new_branch(dir: str, branch: str) -> None:
+    """Create and switch to a new branch."""
+    ...
+
+def git_config_set(dir: str, key: str, value: str) -> None:
+    """Set a git config key in a repo."""
+    ...

dkdc_sh-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "dkdc-sh"
+version = "0.1.0"
+description = "Shell utilities for tmux, git, and command management"
+authors = [{ name = "Cody", email = "cody@dkdc.io" }]
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+readme = "README.md"
+dependencies = []
+
+[dependency-groups]
+dev = ["maturin>=1.0,<2.0", "ruff>=0.9", "ty>=0.0.19", "pytest>=8"]
+
+[tool.maturin]
+module-name = "dkdc_sh.core"
+python-packages = ["dkdc_sh"]
+python-source = "py"
+manifest-path = "crates/sh-py/Cargo.toml"
+
+[build-system]
+requires = ["maturin>=1.0,<2.0"]
+build-backend = "maturin"
+
+[tool.uv]
+cache-keys = [
+    { file = "pyproject.toml" },
+    { file = "crates/sh-core/**/*.rs" },
+    { file = "crates/sh-py/**/*.rs" },
+    { file = "py/dkdc_sh/**/*.py" },
+]