              dir_path.mkdir(parents=True)
      if not no_init:
          project_init(dest, git=git, silent=silent)
      msg.good(f"Your project is now ready!", dest)
      print(f"To fetch the assets, run:\npython -m {NAME} project assets {dest}")
  
  
  @project_cli.command("init")
  def project_init_cli(
      path: Path = Arg(..., help="Path to cloned project", exists=True, file_okay=False),
      git: bool = Opt(False, "--git", "-G", help="Initialize project as a Git repo"),
  ):
      """Initialize a project directory with DVC and Git (optional). This should
      typically be taken care of automatically when you run the "project clone"
      command.
      """
      project_init(path, git=git, silent=True)
  
  
  def project_init(
      dest: Path, *, git: bool = False, silent: bool = False, analytics: bool = False
  ):
 
</s> remove         project_init(dest, git=git, silent=silent)
 </s> add         project_init(project_dir, git=git, silent=True) </s> remove     """Clone a project template from a repository."""
    project_clone(
        name, dest, repo=repo, git=git, no_init=no_init, verbose=verbose, silent=True
    )
 </s> add     """Clone a project template from a repository. Calls into "git" and will
    only download the files from the given subdirectory. The GitHub repo
    defaults to the official spaCy template repo, but can be customized
    (including using a private repo). Setting the --git flag will also
    initialize the project directory as a Git repo. If the project is intended
    to be a Git repo, it should be initialized with Git first, before
    initializing DVC (Data Version Control). This allows DVC to integrate with
    Git.
    """
    project_clone(name, dest, repo=repo, git=git, no_init=no_init)


@project_cli.command("init")
def project_init_cli(
    path: Path = Arg(..., help="Path to cloned project", exists=True, file_okay=False),
    git: bool = Opt(False, "--git", "-G", help="Initialize project as a Git repo"),
):
    """Initialize a project directory with DVC and optionally Git. This should
    typically be taken care of automatically when you run the "project clone"
    command, but you can also run it separately. If the project is intended to
    be a Git repo, it should be initialized with Git first, before initializing
    DVC. This allows DVC to integrate with Git.
    """
    project_init(path, git=git, silent=True)


@project_cli.command("assets")
def project_assets_cli(
    # fmt: off
    project_dir: Path = Arg(..., help="Path to cloned project", exists=True, file_okay=False),
    # fmt: on
):
    """Use DVC (Data Version Control) to fetch the assets for the project,
    defined in the "assets" section of the project config. If possible, DVC
    will try to track the files so you can pull changes from upstream. It will
    also try and store the checksum so the assets are versioned. If th file
    can't be tracked or checked, it will be downloaded using curl. If a checksum
    is provided in the project config, the file is only downloaded if no local
    file with the same checksum exists.
    """
    project_assets(project_dir)


@project_cli.command(
    "run-all",
    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
)
def project_run_all_cli(
    # fmt: off
    ctx: typer.Context,
    project_dir: Path = Arg(..., help="Location of project directory", exists=True, file_okay=False),
    show_help: bool = Opt(False, "--help", help="Show help message and available subcommands")
    # fmt: on
):
    """Run all commands defined in the project. This command will use DVC and
    the defined outputs and dependencies in the project config to determine
    which steps need to be re-run and where to start. This means you're only
    re-generating data if the inputs have changed.

    This command calls into "dvc repro" and all additional arguments are passed
    to the "dvc repro" command: https://dvc.org/doc/command-reference/repro
    """
    if show_help:
        print_run_help(project_dir)
    else:
        project_run_all(project_dir, *ctx.args)


@project_cli.command(
    "run", context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
)
def project_run_cli(
    # fmt: off
    ctx: typer.Context,
    project_dir: Path = Arg(..., help="Location of project directory", exists=True, file_okay=False),
    subcommand: str = Arg(None, help="Name of command defined in project config"),
    show_help: bool = Opt(False, "--help", help="Show help message and available subcommands")
    # fmt: on
):
    """Run a named script defined in the project config. If the command is
    part of the default pipeline defined in the "run" section, DVC is used to
    determine whether the step should re-run if its inputs have changed, or
    whether everything is up to date. If the script is not part of the default
    pipeline, it will be called separately without DVC.

    If DVC is used, the command calls into "dvc repro" and all additional
    arguments are passed to the "dvc repro" command:
    https://dvc.org/doc/command-reference/repro
    """
    if show_help or not subcommand:
        print_run_help(project_dir, subcommand)
    else:
        project_run(project_dir, subcommand, *ctx.args)


@project_cli.command("exec", hidden=True)
def project_exec_cli(
    # fmt: off
    project_dir: Path = Arg(..., help="Location of project directory", exists=True, file_okay=False),
    subcommand: str = Arg(..., help="Name of command defined in project config"),
    # fmt: on
):
    """Execute a command defined in the project config. This CLI command is
    only called internally in auto-generated DVC pipelines, as a shortcut for
    multi-step commands in the project config. You typically shouldn't have to
    call it yourself. To run a command, call "run" or "run-all".
    """
    project_exec(project_dir, subcommand)


@project_cli.command("update-dvc")
def project_update_dvc_cli(
    # fmt: off
    project_dir: Path = Arg(..., help="Location of project directory", exists=True, file_okay=False),
    verbose: bool = Opt(False, "--verbose", "-V", help="Print more info"),
    force: bool = Opt(False, "--force", "-F", help="Force update DVC config"),
    # fmt: on
):
    """Update the auto-generated DVC config file. Uses the steps defined in the
    "run" section of the project config. This typically happens automatically
    when running a command, but can also be triggered manually if needed.
    """
    config = load_project_config(project_dir)
    updated = update_dvc_config(project_dir, config, verbose=verbose, force=force)
    if updated:
        msg.good(f"Updated DVC config from {CONFIG_FILE}")
    else:
        msg.info(f"No changes found in {CONFIG_FILE}, no update needed")


app.add_typer(project_cli, name="project")


#################
# CLI FUNCTIONS #
################# </s> remove     with working_dir(dest):
 </s> add     """Initialize a project as a DVC and (optionally) as a Git repo.

    project_dir (Path): Path to project directory.
    git (bool): Also call "git init" to initialize directory as a Git repo.
    silent (bool): Don't print any output (via DVC).
    analytics (bool): Opt-in to DVC analytics (defaults to False).
    """
    with working_dir(project_dir): </s> remove     dest: Path, *, git: bool = False, silent: bool = False, analytics: bool = False
 </s> add     project_dir: Path,
    *,
    git: bool = False,
    silent: bool = False,
    analytics: bool = False, </s> remove     verbose: bool = Opt(False, "--verbose", "-V", help="Show detailed information")
 </s> add 
    print(f"To fetch the assets, run:\n{COMMAND} project assets {dest}")
              dir_path.mkdir(parents=True)
      if not no_init:
          project_init(dest, git=git, silent=silent)
      msg.good(f"Your project is now ready!", dest)
    print(f"To fetch the assets, run:\n{COMMAND} project assets {dest}")
    print(f"To fetch the assets, run:\n{COMMAND} project assets {dest}")
    print(f"To fetch the assets, run:\n{COMMAND} project assets {dest}")
    print(f"To fetch the assets, run:\n{COMMAND} project assets {dest}")
    print(f"To fetch the assets, run:\n{COMMAND} project assets {dest}")
    print(f"To fetch the assets, run:\n{COMMAND} project assets {dest}")
    print(f"To fetch the assets, run:\n{COMMAND} project assets {dest}")
    print(f"To fetch the assets, run:\n{COMMAND} project assets {dest}")
    print(f"To fetch the assets, run:\n{COMMAND} project assets {dest}")
    print(f"To fetch the assets, run:\n{COMMAND} project assets {dest}")
    print(f"To fetch the assets, run:\n{COMMAND} project assets {dest}")
    print(f"To fetch the assets, run:\n{COMMAND} project assets {dest}")
    print(f"To fetch the assets, run:\n{COMMAND} project assets {dest}")
  
  
  def project_init(
      dest: Path, *, git: bool = False, silent: bool = False, analytics: bool = False
  ):
keep keep keep keep replace replace replace replace replace replace replace replace replace replace replace replace replace keep keep keep keep keep
 Tidy up, document and add custom clone logic 
spacy/cli/project.py