Auto-detect repo from git remote when --repo is omitted

Add shared parse_repo_ref, parse_remote_url, resolve_repo_from_remote,
and require_repo utilities to util.rs. Commands now auto-detect the
repository from the git origin remote (for tangled.org/*.tangled.sh
hosts) when --repo is not provided, removing the need to specify it
explicitly inside a cloned tangled repo directory.

Co-Authored-By: Claude Opus 4.6 <[e-mail]>

crates/tangled-cli/src/cli.rs

···
 
 #[derive(Args, Debug, Clone)]
 pub struct KnotMigrateArgs {
-    /// Repo to migrate: <owner>/<name> (owner defaults to your handle)
+    /// Repo to migrate: <owner>/<name> (auto-detected from git remote if omitted)
     #[arg(long)]
-    pub repo: String,
+    pub repo: Option<String>,
     /// Target knot hostname (e.g. knot1.tangled.sh)
     #[arg(long, value_name = "HOST")]
     pub to: String,
···
 
 #[derive(Args, Debug, Clone)]
 pub struct SpindleSecretListArgs {
-    /// Repo: <owner>/<name>
+    /// Repo: <owner>/<name> (auto-detected from git remote if omitted)
     #[arg(long)]
-    pub repo: String,
+    pub repo: Option<String>,
 }
 
 #[derive(Args, Debug, Clone)]
 pub struct SpindleSecretAddArgs {
-    /// Repo: <owner>/<name>
+    /// Repo: <owner>/<name> (auto-detected from git remote if omitted)
     #[arg(long)]
-    pub repo: String,
+    pub repo: Option<String>,
     /// Secret key
     #[arg(long)]
     pub key: String,
···
 
 #[derive(Args, Debug, Clone)]
 pub struct SpindleSecretRemoveArgs {
-    /// Repo: <owner>/<name>
+    /// Repo: <owner>/<name> (auto-detected from git remote if omitted)
     #[arg(long)]
-    pub repo: String,
+    pub repo: Option<String>,
     /// Secret key
     #[arg(long)]
     pub key: String,

crates/tangled-cli/src/commands/issue.rs

···
         .unwrap_or_else(|| "https://bsky.social".into());
     let client = tangled_api::TangledClient::new(&pds);
 
-    let repo_filter_at = if let Some(repo) = &args.repo {
-        let (owner, name) = parse_repo_ref(repo, &session.handle);
+    let effective_repo = args
+        .repo
+        .clone()
+        .or_else(|| crate::util::resolve_repo_from_remote());
+    let repo_filter_at = if let Some(repo) = &effective_repo {
+        let (owner, name) = crate::util::parse_repo_ref(repo, &session.handle);
         let info = client
             .get_repo_info(owner, name, Some(session.access_jwt.as_str()))
             .await?;
···
         .unwrap_or_else(|| "https://bsky.social".into());
     let client = tangled_api::TangledClient::new(&pds);
 
-    let repo = args
-        .repo
-        .as_ref()
-        .ok_or_else(|| anyhow!("--repo is required for issue create"))?;
-    let (owner, name) = parse_repo_ref(repo, &session.handle);
+    let repo = crate::util::require_repo(args.repo.as_deref())?;
+    let (owner, name) = crate::util::parse_repo_ref(&repo, &session.handle);
     let info = client
         .get_repo_info(owner, name, Some(session.access_jwt.as_str()))
         .await?;
···
         println!("Issue closed");
     }
     Ok(())
-}
-
-fn parse_repo_ref<'a>(spec: &'a str, default_owner: &'a str) -> (&'a str, &'a str) {
-    if let Some((owner, name)) = spec.split_once('/') {
-        (owner, name)
-    } else {
-        (default_owner, spec)
-    }
 }
 
 fn parse_record_id<'a>(id: &'a str, default_did: &'a str) -> Result<(String, String)> {

crates/tangled-cli/src/commands/knot.rs

···
         .url()
         .ok_or_else(|| anyhow!("origin has no URL"))?
         .to_string();
-    let (origin_owner, origin_name, _origin_host) = parse_remote_url(&origin_url)
+    let (origin_owner, origin_name, _origin_host) = crate::util::parse_remote_url(&origin_url)
         .ok_or_else(|| anyhow!("unsupported origin URL: {}", origin_url))?;
 
-    let (owner, name) = parse_repo_ref(&args.repo, &session.handle);
+    let repo_str = crate::util::require_repo(args.repo.as_deref())?;
+    let (owner, name) = crate::util::parse_repo_ref(&repo_str, &session.handle);
     if origin_owner.trim_start_matches('@') != owner.trim_start_matches('@') || origin_name != name
     {
         return Err(anyhow!(
···
         .unwrap_or_else(|| "https://bsky.social".into());
     let pds_client = tangled_api::TangledClient::new(&pds);
     let info = pds_client
-        .get_repo_info(owner, &name, Some(session.access_jwt.as_str()))
+        .get_repo_info(owner, name, Some(session.access_jwt.as_str()))
         .await?;
 
     // Build a publicly accessible source URL on tangled.org for the existing repo
···
     let client = tangled_api::TangledClient::default();
     let opts = tangled_api::client::CreateRepoOptions {
         did: &session.did,
-        name: &name,
+        name,
         knot: &args.to,
         description: info.description.as_deref(),
         default_branch: None,
···
     Ok(())
 }
 
-fn parse_repo_ref<'a>(spec: &'a str, default_owner: &'a str) -> (&'a str, String) {
-    if let Some((owner, name)) = spec.split_once('/') {
-        (owner, name.to_string())
-    } else {
-        (default_owner, spec.to_string())
-    }
-}
-
-fn parse_remote_url(url: &str) -> Option<(String, String, String)> {
-    // Returns (owner, name, host)
-    if let Some(rest) = url.strip_prefix("git@") {
-        // git@host:owner/name(.git)
-        let mut parts = rest.split(':');
-        let host = parts.next()?.to_string();
-        let path = parts.next()?;
-        let mut segs = path.trim_end_matches(".git").split('/');
-        let owner = segs.next()?.to_string();
-        let name = segs.next()?.to_string();
-        return Some((owner, name, host));
-    }
-    if url.starts_with("http://") || url.starts_with("https://") {
-        if let Ok(parsed) = url::Url::parse(url) {
-            let host = parsed.host_str().unwrap_or("").to_string();
-            let path = parsed.path().trim_matches('/');
-            // paths may be like '@owner/name' or 'owner/name'
-            let mut segs = path.trim_end_matches(".git").split('/');
-            let first = segs.next()?;
-            let owner = first.trim_start_matches('@').to_string();
-            let name = segs.next()?.to_string();
-            return Some((owner, name, host));
-        }
-    }
-    None
-}

crates/tangled-cli/src/commands/pr.rs

···
         .or_else(|| std::env::var("TANGLED_PDS_BASE").ok())
         .unwrap_or_else(|| "https://bsky.social".into());
     let client = tangled_api::TangledClient::new(&pds);
-    let target_repo_at = if let Some(repo) = &args.repo {
-        let (owner, name) = parse_repo_ref(repo, &session.handle);
+    let effective_repo = args
+        .repo
+        .clone()
+        .or_else(|| crate::util::resolve_repo_from_remote());
+    let target_repo_at = if let Some(repo) = &effective_repo {
+        let (owner, name) = crate::util::parse_repo_ref(repo, &session.handle);
         let info = client
             .get_repo_info(owner, name, Some(session.access_jwt.as_str()))
             .await?;
···
         .unwrap_or_else(|| "https://bsky.social".into());
     let client = tangled_api::TangledClient::new(&pds);
 
-    let repo = args
-        .repo
-        .as_ref()
-        .ok_or_else(|| anyhow!("--repo is required for pr create"))?;
-    let (owner, name) = parse_repo_ref(repo, "");
+    let repo = crate::util::require_repo(args.repo.as_deref())?;
+    let (owner, name) = crate::util::parse_repo_ref(&repo, "");
     let info = client
         .get_repo_info(owner, name, Some(session.access_jwt.as_str()))
         .await?;
···
     }
 
     Ok(())
-}
-
-fn parse_repo_ref<'a>(spec: &'a str, default_owner: &'a str) -> (&'a str, &'a str) {
-    if let Some((owner, name)) = spec.split_once('/') {
-        if !owner.is_empty() {
-            (owner, name)
-        } else {
-            (default_owner, name)
-        }
-    } else {
-        (default_owner, spec)
-    }
 }
 
 fn parse_record_id<'a>(id: &'a str, default_did: &'a str) -> Result<(String, String)> {

crates/tangled-cli/src/commands/repo.rs

···
 async fn clone(args: RepoCloneArgs) -> Result<()> {
     let session = crate::util::load_session_with_refresh().await?;
 
-    let (owner, name) = parse_repo_ref(&args.repo, &session.handle);
+    let (owner, name) = crate::util::parse_repo_ref(&args.repo, &session.handle);
     let pds = session
         .pds
         .clone()
···
         .unwrap_or_else(|| "https://bsky.social".into());
     let pds_client = tangled_api::TangledClient::new(&pds);
     let info = pds_client
-        .get_repo_info(owner, &name, Some(session.access_jwt.as_str()))
+        .get_repo_info(owner, name, Some(session.access_jwt.as_str()))
         .await?;
 
     let remote = if args.https {
···
         format!("git@{}:{}/{}", knot, owner.trim_start_matches('@'), name)
     };
 
-    let target = PathBuf::from(&name);
+    let target = PathBuf::from(name);
     println!("Cloning {} -> {:?}", remote, target);
 
     let mut callbacks = RemoteCallbacks::new();
···
 
 async fn info(args: RepoInfoArgs) -> Result<()> {
     let session = crate::util::load_session_with_refresh().await?;
-    let (owner, name) = parse_repo_ref(&args.repo, &session.handle);
+    let (owner, name) = crate::util::parse_repo_ref(&args.repo, &session.handle);
     let pds = session
         .pds
         .clone()
···
         .unwrap_or_else(|| "https://bsky.social".into());
     let pds_client = tangled_api::TangledClient::new(&pds);
     let info = pds_client
-        .get_repo_info(owner, &name, Some(session.access_jwt.as_str()))
+        .get_repo_info(owner, name, Some(session.access_jwt.as_str()))
         .await?;
 
     println!("NAME:        {}", info.name);
···
 
 async fn delete(args: RepoDeleteArgs) -> Result<()> {
     let session = crate::util::load_session_with_refresh().await?;
-    let (owner, name) = parse_repo_ref(&args.repo, &session.handle);
+    let (owner, name) = crate::util::parse_repo_ref(&args.repo, &session.handle);
     let pds = session
         .pds
         .clone()
···
         .unwrap_or_else(|| "https://bsky.social".into());
     let pds_client = tangled_api::TangledClient::new(&pds);
     let record = pds_client
-        .get_repo_info(owner, &name, Some(session.access_jwt.as_str()))
+        .get_repo_info(owner, name, Some(session.access_jwt.as_str()))
         .await?;
     let did = record.did;
     let api = tangled_api::TangledClient::default();
-    api.delete_repo(&did, &name, &pds, &session.access_jwt)
+    api.delete_repo(&did, name, &pds, &session.access_jwt)
         .await?;
     println!("Deleted repo '{}'", name);
     Ok(())
···
 
 async fn star(args: RepoRefArgs) -> Result<()> {
     let session = crate::util::load_session_with_refresh().await?;
-    let (owner, name) = parse_repo_ref(&args.repo, &session.handle);
+    let (owner, name) = crate::util::parse_repo_ref(&args.repo, &session.handle);
     let pds = session
         .pds
         .clone()
···
         .unwrap_or_else(|| "https://bsky.social".into());
     let pds_client = tangled_api::TangledClient::new(&pds);
     let info = pds_client
-        .get_repo_info(owner, &name, Some(session.access_jwt.as_str()))
+        .get_repo_info(owner, name, Some(session.access_jwt.as_str()))
         .await?;
     let subject = format!("at://{}/sh.tangled.repo/{}", info.did, info.rkey);
     let api = tangled_api::TangledClient::default();
···
 
 async fn unstar(args: RepoRefArgs) -> Result<()> {
     let session = crate::util::load_session_with_refresh().await?;
-    let (owner, name) = parse_repo_ref(&args.repo, &session.handle);
+    let (owner, name) = crate::util::parse_repo_ref(&args.repo, &session.handle);
     let pds = session
         .pds
         .clone()
···
         .unwrap_or_else(|| "https://bsky.social".into());
     let pds_client = tangled_api::TangledClient::new(&pds);
     let info = pds_client
-        .get_repo_info(owner, &name, Some(session.access_jwt.as_str()))
+        .get_repo_info(owner, name, Some(session.access_jwt.as_str()))
         .await?;
     let subject = format!("at://{}/sh.tangled.repo/{}", info.did, info.rkey);
     let api = tangled_api::TangledClient::default();
···
     Ok(())
 }
 
-fn parse_repo_ref<'a>(spec: &'a str, default_owner: &'a str) -> (&'a str, String) {
-    if let Some((owner, name)) = spec.split_once('/') {
-        (owner, name.to_string())
-    } else {
-        (default_owner, spec.to_string())
-    }
-}

crates/tangled-cli/src/commands/spindle.rs

···
         .unwrap_or_else(|| "https://bsky.social".into());
     let pds_client = tangled_api::TangledClient::new(&pds);
 
-    let (owner, name) = parse_repo_ref(
-        args.repo.as_deref().unwrap_or(&session.handle),
-        &session.handle
+    let effective_repo = args
+        .repo
+        .clone()
+        .or_else(|| crate::util::resolve_repo_from_remote());
+    let (owner, name) = crate::util::parse_repo_ref(
+        effective_repo.as_deref().unwrap_or(&session.handle),
+        &session.handle,
     );
     let info = pds_client
         .get_repo_info(owner, name, Some(session.access_jwt.as_str()))
···
         .unwrap_or_else(|| "https://bsky.social".into());
     let pds_client = tangled_api::TangledClient::new(&pds);
 
-    let (owner, name) = parse_repo_ref(
-        args.repo.as_deref().unwrap_or(&session.handle),
-        &session.handle
+    let effective_repo = args
+        .repo
+        .clone()
+        .or_else(|| crate::util::resolve_repo_from_remote());
+    let (owner, name) = crate::util::parse_repo_ref(
+        effective_repo.as_deref().unwrap_or(&session.handle),
+        &session.handle,
     );
     let info = pds_client
         .get_repo_info(owner, name, Some(session.access_jwt.as_str()))
···
 }
 
 async fn run_pipeline(args: SpindleRunArgs) -> Result<()> {
+    let effective_repo = args
+        .repo
+        .clone()
+        .or_else(|| crate::util::resolve_repo_from_remote());
     println!(
         "Spindle run (stub) repo={:?} branch={:?} wait={}",
-        args.repo, args.branch, args.wait
+        effective_repo, args.branch, args.wait
     );
     Ok(())
 }
···
 
 async fn secret_list(args: SpindleSecretListArgs) -> Result<()> {
     let session = crate::util::load_session_with_refresh().await?;
+    let repo_str = crate::util::require_repo(args.repo.as_deref())?;
     let pds = session
         .pds
         .clone()
         .or_else(|| std::env::var("TANGLED_PDS_BASE").ok())
         .unwrap_or_else(|| "https://bsky.social".into());
     let pds_client = tangled_api::TangledClient::new(&pds);
-    let (owner, name) = parse_repo_ref(&args.repo, &session.handle);
+    let (owner, name) = crate::util::parse_repo_ref(&repo_str, &session.handle);
     let info = pds_client
         .get_repo_info(owner, name, Some(session.access_jwt.as_str()))
         .await?;
···
         .list_repo_secrets(&pds, &session.access_jwt, &repo_at)
         .await?;
     if secrets.is_empty() {
-        println!("No secrets configured for {}", args.repo);
+        println!("No secrets configured for {}", repo_str);
     } else {
         println!("KEY\tCREATED AT\tCREATED BY");
         for s in secrets {
···
 
 async fn secret_add(args: SpindleSecretAddArgs) -> Result<()> {
     let session = crate::util::load_session_with_refresh().await?;
+    let repo_str = crate::util::require_repo(args.repo.as_deref())?;
     let pds = session
         .pds
         .clone()
         .or_else(|| std::env::var("TANGLED_PDS_BASE").ok())
         .unwrap_or_else(|| "https://bsky.social".into());
     let pds_client = tangled_api::TangledClient::new(&pds);
-    let (owner, name) = parse_repo_ref(&args.repo, &session.handle);
+    let (owner, name) = crate::util::parse_repo_ref(&repo_str, &session.handle);
     let info = pds_client
         .get_repo_info(owner, name, Some(session.access_jwt.as_str()))
         .await?;
···
 
     api.add_repo_secret(&pds, &session.access_jwt, &repo_at, &args.key, &value)
         .await?;
-    println!("Added secret '{}' to {}", args.key, args.repo);
+    println!("Added secret '{}' to {}", args.key, repo_str);
     Ok(())
 }
 
 async fn secret_remove(args: SpindleSecretRemoveArgs) -> Result<()> {
     let session = crate::util::load_session_with_refresh().await?;
+    let repo_str = crate::util::require_repo(args.repo.as_deref())?;
     let pds = session
         .pds
         .clone()
         .or_else(|| std::env::var("TANGLED_PDS_BASE").ok())
         .unwrap_or_else(|| "https://bsky.social".into());
     let pds_client = tangled_api::TangledClient::new(&pds);
-    let (owner, name) = parse_repo_ref(&args.repo, &session.handle);
+    let (owner, name) = crate::util::parse_repo_ref(&repo_str, &session.handle);
     let info = pds_client
         .get_repo_info(owner, name, Some(session.access_jwt.as_str()))
         .await?;
···
 
     api.remove_repo_secret(&pds, &session.access_jwt, &repo_at, &args.key)
         .await?;
-    println!("Removed secret '{}' from {}", args.key, args.repo);
+    println!("Removed secret '{}' from {}", args.key, repo_str);
     Ok(())
 }
-
-fn parse_repo_ref<'a>(spec: &'a str, default_owner: &'a str) -> (&'a str, &'a str) {
-    if let Some((owner, name)) = spec.split_once('/') {
-        (owner, name)
-    } else {
-        (default_owner, spec)
-    }
-}

crates/tangled-cli/src/util.rs

···
 use anyhow::{anyhow, Result};
+use std::path::Path;
 use tangled_config::session::{Session, SessionManager};
 
 /// Load session and automatically refresh if expired
···
 
     Ok(session)
 }
+
+/// Split "owner/name" into (owner, name), defaulting owner if no slash present.
+pub fn parse_repo_ref<'a>(spec: &'a str, default_owner: &'a str) -> (&'a str, &'a str) {
+    if let Some((owner, name)) = spec.split_once('/') {
+        if !owner.is_empty() {
+            (owner, name)
+        } else {
+            (default_owner, name)
+        }
+    } else {
+        (default_owner, spec)
+    }
+}
+
+/// Parse a git remote URL into (owner, name, host).
+pub fn parse_remote_url(url: &str) -> Option<(String, String, String)> {
+    if let Some(rest) = url.strip_prefix("git@") {
+        let mut parts = rest.split(':');
+        let host = parts.next()?.to_string();
+        let path = parts.next()?;
+        let mut segs = path.trim_end_matches(".git").split('/');
+        let owner = segs.next()?.to_string();
+        let name = segs.next()?.to_string();
+        return Some((owner, name, host));
+    }
+    if url.starts_with("http://") || url.starts_with("https://") {
+        if let Ok(parsed) = url::Url::parse(url) {
+            let host = parsed.host_str().unwrap_or("").to_string();
+            let path = parsed.path().trim_matches('/');
+            let mut segs = path.trim_end_matches(".git").split('/');
+            let first = segs.next()?;
+            let owner = first.trim_start_matches('@').to_string();
+            let name = segs.next()?.to_string();
+            return Some((owner, name, host));
+        }
+    }
+    None
+}
+
+/// Try to detect "owner/name" from the git remote of the current directory.
+pub fn resolve_repo_from_remote() -> Option<String> {
+    let repo = git2::Repository::discover(Path::new(".")).ok()?;
+    let remote = repo
+        .find_remote("origin")
+        .or_else(|_| {
+            repo.remotes().and_then(|rems| {
+                rems.get(0)
+                    .ok_or(git2::Error::from_str("no remotes configured"))
+                    .and_then(|name| repo.find_remote(name))
+            })
+        })
+        .ok()?;
+    let url = remote.url()?.to_string();
+    let (owner, name, host) = parse_remote_url(&url)?;
+    if host == "tangled.org" || host.ends_with(".tangled.sh") {
+        Some(format!("{}/{}", owner, name))
+    } else {
+        None
+    }
+}
+
+/// Resolve repo from --repo flag or git remote, returning a clear error if neither works.
+pub fn require_repo(flag: Option<&str>) -> Result<String> {
+    if let Some(repo) = flag {
+        return Ok(repo.to_string());
+    }
+    resolve_repo_from_remote().ok_or_else(|| {
+        anyhow!("could not determine repository. Use --repo or run from inside a tangled repo directory")
+    })
+}