feat(clone): add git-like clone command and docs

Author: nikivdev

docs/commands/clone.md

@@ -0,0 +1,41 @@
+# f clone
+
+Clone a repository with git-like destination behavior.
+
+## Overview
+
+`f clone` behaves like `git clone` for destination paths:
+
+- `f clone <url>` clones into the current working directory using Git's default folder naming.
+- `f clone <url> <dir>` clones into an explicit destination directory.
+
+For GitHub inputs, Flow normalizes clone URLs to SSH:
+
+- `https://github.com/owner/repo` -> `git@github.com:owner/repo.git`
+- `owner/repo` -> `git@github.com:owner/repo.git`
+
+This command does not force clones into `~/repos` and does not auto-configure `upstream`.
+
+## Usage
+
+```bash
+f clone <url-or-owner/repo> [directory]
+```
+
+## Examples
+
+```bash
+# GitHub URL -> SSH clone URL
+f clone https://github.com/genxai/new
+
+# owner/repo shorthand -> SSH clone URL
+f clone genxai/new
+
+# explicit destination folder (same as git clone)
+f clone genxai/new my-local-new
+```
+
+## When To Use
+
+- Use `f clone` when you want standard `git clone` destination behavior.
+- Use [`f repos clone`](repos.md) when you want managed placement under `~/repos/<owner>/<repo>` plus optional upstream automation.

docs/commands/readme.md

@@ -10,6 +10,7 @@ Complete documentation for all `f` (flow) commands.
 | [`release`](release.md) | Publish a release to registry or GitHub |
 | [`publish`](publish.md) | Publish project to GitHub |
 | [`install`](install.md) | Install a CLI/tool via registry, parm, or flox |
+| [`clone`](clone.md) | Clone repositories with git-like destination behavior |
 | [`repos`](repos.md) | Clone repositories into ~/repos |
 | [`new`](new.md) | Create a project from a local template in ~/new |
 | [`commit`](commit.md) | AI-powered commit with code review |
@@ -53,6 +54,7 @@ f commit --help
 
 - **[commit](commit.md)** - AI-powered commits with review
 - **[pr](pr.md)** - PR creation/editing plus review feedback ingestion
+- **[clone](clone.md)** - Clone with git-like destination behavior
 - **[repos](repos.md)** - Clone repos into a structured directory
 - **[upstream](upstream.md)** - Fork management and sync
 - **[fixup](fixup.md)** - Fix common TOML syntax errors

docs/commands/repos.md

@@ -2,6 +2,8 @@
 
 Clone repositories into a structured local directory or create new ones.
 
+If you want standard `git clone` destination behavior, use [`f clone`](clone.md) instead.
+
 ## Overview
 
 `f repos clone` clones GitHub repositories into `~/repos/<owner>/<repo>` using SSH URLs. By default it does a shallow clone for speed, then fetches full history in the background. It always sets up an `upstream` remote and local tracking branch unless you pass `--no-upstream`.

docs/index.mdx

@@ -15,6 +15,7 @@ High-signal docs for the Codex/Claude workflow:
 - [`ci-cd-runbook.md`](ci-cd-runbook.md): CI/CD architecture, runner-mode operations, and failure debug checklist for canary/release pipelines.
 - [`rise.md`](rise.md): full integration guide for installing and operating Rise via Flow (`f install rise`) across adopt/sync/dev/mobile/schema/sandbox workflows.
 - [`commands/domains.md`](commands/domains.md): shared local `*.localhost` proxy ownership via `f domains` (prevents per-repo port-80 collisions).
+- [`commands/clone.md`](commands/clone.md): git-like cloning (`f clone`) with GitHub URL/shorthand normalization to SSH, without forcing `~/repos`.
 - [`commands/up.md`](commands/up.md): one-command project startup (`f up`) with optional lifecycle domain setup.
 - [`commands/down.md`](commands/down.md): one-command project shutdown (`f down`) with lifecycle teardown rules.
 - [`commands/reviews-todo.md`](commands/reviews-todo.md): fast-commit + deferred Codex deep-review backlog workflow.

docs/moving-repos.md

@@ -14,6 +14,18 @@ Flow uses three managed roots:
 
 ## Cloning Into the Right Place
 
+### `f clone`
+
+Clones with git-like destination behavior from your current working directory:
+
+```bash
+f clone owner/repo
+f clone https://github.com/owner/repo
+f clone owner/repo local-folder
+```
+
+GitHub inputs are normalized to SSH URLs, but destination behavior matches `git clone` (no forced `~/repos` root).
+
 ### `f repos clone`
 
 Clones GitHub repos into `~/repos/<owner>/<repo>`:
@@ -189,6 +201,7 @@ f code move-sessions --from ~/code/old --to ~/code/new
 
 ## See Also
 
+- [commands/clone.md](commands/clone.md) — `f clone` (git-like destination behavior)
 - [commands/repos.md](commands/repos.md) — `f repos clone` / `f repos create`
 - [commands/migrate.md](commands/migrate.md) — `f migrate` full reference
 - [run-repos.md](run-repos.md) — run repo shortcuts

src/cli.rs

@@ -512,6 +512,11 @@ pub enum Commands {
         long_about = "Publish the current project. Without a subcommand, shows a fuzzy picker to choose the target."
     )]
     Publish(PublishCommand),
+    #[command(
+        about = "Clone a repository into the current directory (git clone style).",
+        long_about = "Clones into the current working directory by default, matching git clone destination behavior. GitHub inputs are normalized to SSH URLs."
+    )]
+    Clone(CloneOpts),
     #[command(
         about = "Clone repositories into a structured local directory.",
         long_about = "Clone repositories into ~/repos/<owner>/<repo> with SSH URLs and optional upstream setup for forks."
@@ -3233,6 +3238,14 @@ pub struct PublishCommand {
     pub action: Option<PublishAction>,
 }
 
+#[derive(Args, Debug, Clone)]
+pub struct CloneOpts {
+    /// Repository URL or owner/repo.
+    pub url: String,
+    /// Optional destination directory (same as git clone <url> <dir>).
+    pub directory: Option<String>,
+}
+
 #[derive(Subcommand, Debug, Clone)]
 pub enum PublishAction {
     /// Publish to gitedit.dev.

src/main.rs

@@ -540,6 +540,9 @@ fn main() -> Result<()> {
             Some(Commands::Publish(cmd)) => {
                 publish::run(cmd)?;
             }
+            Some(Commands::Clone(opts)) => {
+                repos::clone_git_like(opts)?;
+            }
             Some(Commands::Repos(cmd)) => {
                 repos::run(cmd)?;
             }

src/repos.rs

@@ -11,7 +11,7 @@ use anyhow::{Context, Result, bail};
 use serde::Deserialize;
 use url::Url;
 
-use crate::cli::{ReposAction, ReposCloneOpts, ReposCommand};
+use crate::cli::{CloneOpts, ReposAction, ReposCloneOpts, ReposCommand};
 use crate::{config, publish, ssh, ssh_keys, upstream, vcs};
 
 const DEFAULT_REPOS_ROOT: &str = "~/repos";
@@ -30,6 +30,43 @@ pub fn run(cmd: ReposCommand) -> Result<()> {
     }
 }
 
+/// Clone into the current working directory (git clone style destination behavior).
+pub fn clone_git_like(opts: CloneOpts) -> Result<()> {
+    ssh::ensure_ssh_env();
+    let mode = ssh::ssh_mode();
+    if matches!(mode, ssh::SshMode::Force) && !ssh::has_identities() {
+        match ssh_keys::ensure_default_identity(24) {
+            Ok(()) => {}
+            Err(err) => {
+                bail!(
+                    "SSH mode is forced but no key is available. Run `f ssh setup` or `f ssh unlock` (error: {})",
+                    err
+                );
+            }
+        }
+    }
+
+    let clone_url = resolve_git_like_clone_url(&opts.url)?;
+    let mut cmd = Command::new("git");
+    cmd.arg("clone").arg(&clone_url);
+    if let Some(dir) = opts.directory {
+        cmd.arg(dir);
+    }
+
+    let status = cmd
+        .stdin(Stdio::inherit())
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
+        .status()
+        .context("failed to run git clone")?;
+
+    if !status.success() {
+        bail!("git clone failed");
+    }
+
+    Ok(())
+}
+
 fn open_in_zed(path: &std::path::Path) -> Result<()> {
     std::process::Command::new("open")
         .args(["-a", "/Applications/Zed Preview.app"])
@@ -438,6 +475,55 @@ fn parse_repo_target(input: &str) -> Result<RepoTarget> {
     Ok(RepoTarget::Generic(generic))
 }
 
+fn resolve_git_like_clone_url(input: &str) -> Result<String> {
+    let trimmed = input.trim();
+    if trimmed.is_empty() {
+        bail!("missing repository URL");
+    }
+
+    if trimmed.starts_with("git@github.com:")
+        || trimmed.contains("github.com/")
+        || looks_like_github_shorthand(trimmed)
+    {
+        let repo_ref = parse_github_repo(trimmed)?;
+        return Ok(format!(
+            "git@github.com:{}/{}.git",
+            repo_ref.owner, repo_ref.repo
+        ));
+    }
+
+    Ok(trimmed.to_string())
+}
+
+fn looks_like_github_shorthand(input: &str) -> bool {
+    if input.contains("://")
+        || input.contains('@')
+        || input.starts_with('/')
+        || input.starts_with("./")
+        || input.starts_with("../")
+        || input.starts_with("~/")
+    {
+        return false;
+    }
+
+    let mut parts = input.split('/');
+    let Some(owner) = parts.next() else {
+        return false;
+    };
+    let Some(repo) = parts.next() else {
+        return false;
+    };
+    if parts.next().is_some() {
+        return false;
+    }
+
+    if owner.is_empty() || repo.is_empty() {
+        return false;
+    }
+
+    owner != "." && owner != ".." && repo != "." && repo != ".."
+}
+
 fn is_github_input(input: &str) -> bool {
     let trimmed = input.trim();
     if trimmed.starts_with("git@github.com:") || trimmed.contains("github.com/") {

src/usage.rs

@@ -318,6 +318,7 @@ fn command_path(raw_args: &[String]) -> String {
         "deploy",
         "prod",
         "publish",
+        "clone",
         "repos",
         "code",
         "migrate",