uv init initializes git repository

Add tests

`uv init` initializes git repository

Add tests

tmp

crates/uv-cli/src/lib.rs

@@ -13,7 +13,7 @@ use pypi_types::VerbatimParsedUrl;
 use uv_cache::CacheArgs;
 use uv_configuration::{
  ConfigSettingEntry, ExportFormat, IndexStrategy, KeyringProviderType, PackageNameSpecifier,
- TargetTriple, TrustedHost,
+ TargetTriple, TrustedHost, VersionControl,
 };
 use uv_normalize::{ExtraName, PackageName};
 use uv_python::{PythonDownloads, PythonPreference, PythonVersion};
@@ -2310,6 +2310,13 @@ pub struct InitArgs {
  #[arg(long, alias = "library", conflicts_with = "app")]
  pub r#lib: bool,
 
+ /// Initialize a new repository for the given version control system.
+ ///
+ /// By default, uv will try to initialize a Git repository (`git`).
+ /// Use `none` to skip repository initialization.
+ #[arg(long, value_enum)]
+ pub vcs: Option<VersionControl>,
+
  /// Do not create a `README.md` file.
  #[arg(long)]
  pub no_readme: bool,

crates/uv-configuration/Cargo.toml

@@ -19,17 +19,23 @@ platform-tags = { workspace = true }
 pypi-types = { workspace = true }
 uv-auth = { workspace = true }
 uv-cache = { workspace = true }
+uv-fs = { workspace = true }
 uv-normalize = { workspace = true }
+uv-warnings = { workspace = true }
 
+anyhow = { workspace = true }
 clap = { workspace = true, features = ["derive"], optional = true }
 either = { workspace = true }
+fs-err = { workspace = true }
+indoc = { workspace = true }
 rustc-hash = { workspace = true }
 schemars = { workspace = true, optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 url = { workspace = true }
+which = { workspace = true }
 
 [dev-dependencies]
 anyhow = { workspace = true }

crates/uv-configuration/src/lib.rs

@@ -14,6 +14,7 @@ pub use preview::*;
 pub use sources::*;
 pub use target_triple::*;
 pub use trusted_host::*;
+pub use vcs_options::*;
 
 mod authentication;
 mod build_options;
@@ -31,3 +32,4 @@ mod preview;
 mod sources;
 mod target_triple;
 mod trusted_host;
+mod vcs_options;

crates/uv-configuration/src/vcs_options.rs

@@ -0,0 +1,123 @@
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
+use std::str::FromStr;
+
+use anyhow::{Context, Result};
+use serde::Deserialize;
+
+use uv_fs::Simplified;
+use uv_warnings::warn_user;
+
+/// The version control system to use.
+#[derive(Clone, Copy, Debug, PartialEq, Default, Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+#[cfg_attr(feature = "clap", derive(clap::ValueEnum))]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+pub enum VersionControl {
+ /// Use Git for version control.
+ #[default]
+ Git,
+
+ /// Do not use version control.
+ None,
+}
+
+impl VersionControl {
+ /// Initializes the VCS system based on the provided path.
+ pub fn init(&self, path: &PathBuf) -> Result<()> {
+ match self {
+ VersionControl::None => Ok(()),
+ VersionControl::Git => Self::init_git(path),
+ }
+ }
+
+ fn init_git(path: &PathBuf) -> Result<()> {
+ let Ok(git) = which::which("git") else {
+ anyhow::bail!("could not find `git` in PATH");
+ };
+
+ if path.join(".git").try_exists()? {
+ warn_user!(
+ "Git repository already exists at `{}`",
+ path.simplified_display()
+ );
+ } else {
+ if !Command::new(git)
+ .arg("init")
+ .current_dir(path)
+ .stdout(Stdio::null())
+ .stderr(Stdio::null())
+ .status()
+ .context("failed to run `git init`")?
+ .success()
+ {
+ anyhow::bail!("`git init` failed at `{}`", path.simplified_display());
+ }
+ }
+
+ // Create the `.gitignore` if it does not already exist.
+ let gitignore = path.join(".gitignore");
+ if !gitignore.try_exists()? {
+ fs_err::write(gitignore, gitignore_content())?;
+ };
+
+ Ok(())
+ }
+}
+
+/// The default content for a `.gitignore` file in a Python project.
+fn gitignore_content() -> &'static str {
+ indoc::indoc! {r"
+ # Python generated files
+ __pycache__/
+ *.py[oc]
+ build/
+ dist/
+ wheels/
+ *.egg-info
+
+ # venv
+ .venv
+ "}
+}
+
+impl FromStr for VersionControl {
+ type Err = String;
+
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ match s {
+ "git" => Ok(VersionControl::Git),
+ "none" => Ok(VersionControl::None),
+ other => Err(format!("unknown vcs specification: `{other}`")),
+ }
+ }
+}
+
+impl std::fmt::Display for VersionControl {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ VersionControl::Git => write!(f, "git"),
+ VersionControl::None => write!(f, "none"),
+ }
+ }
+}
+
+/// Check if the path is inside a VCS repository.
+///
+/// Currently only supports Git.
+pub fn existing_vcs_repo(dir: &Path) -> bool {
+ is_inside_git_work_tree(dir)
+}
+
+/// Check if the path is inside a Git work tree.
+fn is_inside_git_work_tree(dir: &Path) -> bool {
+ Command::new("git")
+ .arg("rev-parse")
+ .arg("--is-inside-work-tree")
+ .current_dir(dir)
+ .stdout(Stdio::null())
+ .stderr(Stdio::null())
+ .status()
+ .map(|status| status.success())
+ .unwrap_or(false)
+}

crates/uv/src/commands/project/init.rs

@@ -3,17 +3,20 @@ use std::path::Path;
 
 use anyhow::{anyhow, Context, Result};
 use owo_colors::OwoColorize;
+
 use pep440_rs::Version;
 use pep508_rs::PackageName;
 use tracing::{debug, warn};
 use uv_cache::Cache;
 use uv_client::{BaseClientBuilder, Connectivity};
+use uv_configuration::{existing_vcs_repo, VersionControl};
 use uv_fs::{Simplified, CWD};
 use uv_python::{
  EnvironmentPreference, PythonDownloads, PythonInstallation, PythonPreference, PythonRequest,
  PythonVersionFile, VersionRequest,
 };
 use uv_resolver::RequiresPython;
+use uv_warnings::warn_user;
 use uv_workspace::pyproject_mut::{DependencyTarget, PyProjectTomlMut};
 use uv_workspace::{DiscoveryOptions, MemberDiscovery, Workspace, WorkspaceError};
 
@@ -33,6 +36,7 @@ pub(crate) async fn init(
  no_pin_python: bool,
  python: Option<String>,
  no_workspace: bool,
+ version_control: Option<VersionControl>,
  python_preference: PythonPreference,
  python_downloads: PythonDownloads,
  connectivity: Connectivity,
@@ -94,6 +98,26 @@ pub(crate) async fn init(
  }
  }
 
+ // Initialize the version control system.
+ let in_existing_vcs = existing_vcs_repo(path.parent().unwrap_or(&path));
+ let vcs = match (version_control, in_existing_vcs) {
+ (None, false) => VersionControl::default(),
+ (None, true) => VersionControl::None,
+ (Some(vcs), false) => vcs,
+ (Some(vcs), true) => {
+ warn_user!(
+ "The project is already in a version control system, `--vcs {vcs}` is ignored",
+ );
+ VersionControl::None
+ }
+ };
+ if let Err(err) = vcs.init(&path) {
+ if version_control.is_some() {
+ return Err(err);
+ }
+ debug!("Failed to initialize version control: {:#}", err);
+ }
+
  match explicit_path {
  // Initialized a project in the current directory.
  None => {

crates/uv/src/lib.rs

@@ -1076,6 +1076,7 @@ async fn run_project(
  args.no_pin_python,
  args.python,
  args.no_workspace,
+ args.version_control,
  globals.python_preference,
  globals.python_downloads,
  globals.connectivity,

crates/uv/src/settings.rs

@@ -24,7 +24,7 @@ use uv_client::Connectivity;
 use uv_configuration::{
  BuildOptions, Concurrency, ConfigSettings, ExportFormat, ExtrasSpecification, HashCheckingMode,
  IndexStrategy, InstallOptions, KeyringProviderType, NoBinary, NoBuild, PreviewMode, Reinstall,
- SourceStrategy, TargetTriple, TrustedHost, Upgrade,
+ SourceStrategy, TargetTriple, TrustedHost, Upgrade, VersionControl,
 };
 use uv_normalize::PackageName;
 use uv_python::{Prefix, PythonDownloads, PythonPreference, PythonVersion, Target};
@@ -156,6 +156,7 @@ pub(crate) struct InitSettings {
  pub(crate) name: Option<PackageName>,
  pub(crate) package: bool,
  pub(crate) kind: InitProjectKind,
+ pub(crate) version_control: Option<VersionControl>,
  pub(crate) no_readme: bool,
  pub(crate) no_pin_python: bool,
  pub(crate) no_workspace: bool,
@@ -174,6 +175,7 @@ impl InitSettings {
  no_package,
  app,
  lib,
+ vcs,
  no_readme,
  no_pin_python,
  no_workspace,
@@ -194,6 +196,7 @@ impl InitSettings {
  name,
  package,
  kind,
+ version_control: vcs,
  no_readme,
  no_pin_python,
  no_workspace,