import Config

config :openagents, :docs_source_dir, Path.expand("../priv/docs", __DIR__)

config :openagents, :repository_provisioner_enabled, false

config :openagents, :runtime_environment, :test

The CLI retrieves the clone URL from the API and starts standard Git.

### `repo delete`

```text

openagents repo delete [OWNER/REPOSITORY] --yes

openagents repo delete --repo OWNER/REPOSITORY --yes

```

The command permanently deletes a repository you own, including its Git

history, issues, projects, and import records. You must pass `--yes`. When you

omit the repository, the CLI infers it from an exact OpenAgents `origin`

remote on the selected API origin.

## JSON and noninteractive use

With `--json`, stdout contains machine-readable output. Human progress and

# Delete a repository

You can permanently delete a repository you own from the website, REST API,

or CLI. Maintainers, contributors, and viewers cannot delete a repository.

Deletion removes the Git history, issues, projects, labels, milestones,

memberships, import receipt, and provisioning records. You cannot undo it.

## Delete from the website

1. Open the repository.

2. Find **Delete repository** near the bottom of the **Code** page.

3. Type the full `OWNER/REPOSITORY` name shown in the confirmation field.

4. Select **Delete repository**.

## Delete with the CLI

```sh

openagents repo delete OWNER/REPOSITORY --yes

```

You can run the same command through `npx`:

```sh

npx --yes @openagentsinc/cli@latest repo delete OWNER/REPOSITORY --yes

```

## Delete with the REST API

```sh

curl --request DELETE \

  --header "Authorization: Bearer $OPENAGENTS_TOKEN" \

  https://openagents.com/api/v3/repos/OWNER/REPOSITORY

```

Success returns `204 No Content`.

- Import a GitHub repository as a one-time copy.

- List and inspect repositories that you can access.

- Clone repositories and configure Git authentication.

- Delete a repository you own with explicit confirmation.

- Push, pull, and fetch through Git smart HTTP.

- Use JSON output and stable exit codes in scripts and agents.

Pull requests, repository deletion, continuous GitHub mirroring, SSH transport,

rulesets, and self-update are not part of this release.

Pull requests, continuous GitHub mirroring, SSH transport, rulesets, and

self-update are not part of this release.

## Namespaces and access

- Select **Import from GitHub** to copy one GitHub repository.

- Open a repository to see its clone URL, lifecycle state, Issues, Projects,

  code, and import receipt when applicable.

- Open a repository's **Delete repository** section to permanently delete a

  repository you own.

## Next steps

- [Create a repository](create-repository.md)

- [Import a GitHub repository](import-github.md)

- [Clone, push, and pull](git.md)

- [Delete a repository](delete-repository.md)

- [CLI command reference](command-reference.md)

openagents repo list

openagents repo view [<owner>/<name>]

openagents repo clone <owner>/<name> [<directory>]

openagents repo delete [<owner>/<name>] --yes

```

`repo create <name>` targets the authenticated user's GitHub user namespace.

`origin` remote when no argument is present. `-R, --repo <owner>/<name>`

overrides inference.

`repo delete` requires repository-owner authority and an explicit `--yes`.

Success permanently removes the repository row, its dependent issue and

project records, the durable WAL prefix, and connected-node bare caches.

Remote inference accepts only clone URLs returned by an admitted OpenAgents

endpoint. It must not treat an arbitrary path that resembles `owner/name` as an

authenticated OpenAgents repository.

Reserve these names without shipping placeholder commands:

```text

openagents repo delete

openagents repo mirror

openagents pr ...

openagents ruleset ...

   visibility, timeout, source head receipt, and no-sync notice.

3. Implement cursor-based `repo list` and `repo view`.

4. Implement `repo clone` using the server-provided clone URL.

5. Implement safe repository inference from an admitted remote and explicit

5. Implement owner-only `repo delete` with explicit confirmation and storage

   cleanup.

6. Implement safe repository inference from an admitted remote and explicit

   `-R` override.

6. Refuse to overwrite an existing unrelated remote.

7. Execute Git with argv arrays, bounded captured output, cancellation, and no

7. Refuse to overwrite an existing unrelated remote.

8. Execute Git with argv arrays, bounded captured output, cancellation, and no

   credential in the remote URL.

8. Keep human progress on stderr when JSON owns stdout.

9. Keep human progress on stderr when JSON owns stdout.

**Tests:** all command options, mutual exclusions, error and exit-code mapping,

idempotent retry, timeout without server cancellation, remote inference, remote

    # be a query each time. Defaults to false, so a user loaded by any other

    # path is treated as new rather than accidentally grandfathered.

    field :agent_surfaces?, :boolean, virtual: true, default: false

    field :sidebar_repository_path, :string, virtual: true

    has_one :storage_owner, OpenAgents.Conversations.Visitor

          public_leaderboard_opted_out: boolean(),

          browser_key_hash: binary() | nil,

          agent_surfaces?: boolean(),

          sidebar_repository_path: String.t() | nil,

          inserted_at: DateTime.t(),

          updated_at: DateTime.t()

        }

  @doc "Absolute path of the bare repository for `repo`."

  def bare_path(repo), do: Path.join([data_dir(), "repos", repo <> ".git"])

  @doc "Delete one repository's disposable local bare-repository cache."

  def delete_repo(storage_key) do

    if valid_storage_key?(storage_key) do

      case File.rm_rf(bare_path(storage_key)) do

        {:ok, _removed} -> :ok

        {:error, reason, _path} -> {:error, reason}

      end

    else

      {:error, :invalid_storage_key}

    end

  end

  @doc "Initialize the bare repository if absent. Returns the path."

  def ensure_repo!(repo, default_branch \\ "main") do

    path = bare_path(repo)

              :ok | {:error, term}

  @callback put_object(repo, object_key :: String.t(), payload :: binary()) ::

              {:ok, String.t()} | {:error, term}

  @callback delete_repo(repo) :: :ok | {:error, term}

  @repo_pattern ~r/^[a-z0-9](?:[a-z0-9_-]|\.(?=[a-z0-9]))*$/

  @entry_key_pattern ~r/^entries\/[0-9]{8}-[0-9a-f]{12}$/

    end

  end

  @doc "Delete every WAL object for one repository. This operation is idempotent."

  @spec delete_repo(repo) :: :ok | {:error, term}

  def delete_repo(repo) do

    with :ok <- validate_repo(repo), do: adapter().delete_repo(repo)

  end

  @doc """

  Store a named artifact blob alongside the WAL (P6, #123): built beam tars

  land here so a replaced node — whose local artifact cache is empty — can

    end

  end

  @impl WAL

  def delete_repo(repo) do

    with {:ok, bucket} <- bucket(),

         {:ok, token} <- token() do

      delete_prefix(bucket, prefix(repo), token)

    end

  end

  ## Object naming (public so it is testable without a live bucket)

  @doc """

  ## Internal

  defp delete_prefix(bucket, object_prefix, token) do

    with {:ok, names} <- list_objects(bucket, object_prefix, token),

         :ok <- delete_objects(bucket, names, token) do

      if names == [], do: :ok, else: delete_prefix(bucket, object_prefix, token)

    end

  end

  defp list_objects(bucket, object_prefix, token) do

    url =

      @storage_base <>

        "/storage/v1/b/#{URI.encode_www_form(bucket)}/o?" <>

        URI.encode_query(prefix: object_prefix, maxResults: 1_000, fields: "items(name)")

    case Req.get(url, headers: auth_headers(token)) do

      {:ok, %Req.Response{status: 200, body: %{"items" => items}}} when is_list(items) ->

        {:ok, Enum.map(items, &Map.fetch!(&1, "name"))}

      {:ok, %Req.Response{status: 200}} ->

        {:ok, []}

      {:ok, %Req.Response{status: status, body: body}} ->

        {:error, {:gcs_error, status, body}}

      {:error, reason} ->

        {:error, reason}

    end

  end

  defp delete_objects(_bucket, [], _token), do: :ok

  defp delete_objects(bucket, names, token) do

    names

    |> Task.async_stream(

      fn name -> delete_object(bucket, name, token) end,

      max_concurrency: 8,

      ordered: false,

      timeout: 60_000

    )

    |> Enum.reduce_while(:ok, fn

      {:ok, :ok}, :ok -> {:cont, :ok}

      {:ok, {:error, reason}}, :ok -> {:halt, {:error, reason}}

      {:exit, reason}, :ok -> {:halt, {:error, reason}}

    end)

  end

  defp delete_object(bucket, name, token) do

    case Req.delete(object_url(bucket, name), headers: auth_headers(token), retry: false) do

      {:ok, %Req.Response{status: status}} when status in [204, 404] -> :ok

      {:ok, %Req.Response{status: status, body: body}} -> {:error, {:gcs_error, status, body}}

      {:error, reason} -> {:error, reason}

    end

  end

  defp fetch_generation(bucket, name) do

    with {:ok, token} <- token() do

      url = object_url(bucket, name) <> "?" <> URI.encode_query(fields: "generation")

    end

  end

  @impl WAL

  def delete_repo(repo) do

    case File.rm_rf(repo_dir(repo)) do

      {:ok, _removed} -> :ok

      {:error, reason, _path} -> {:error, reason}

    end

  end

  ## Internal

  defp do_cas(repo, :none, index) do

  import Ecto.Query, warn: false

  alias OpenAgents.Accounts.User

  alias OpenAgents.{Audit, Repo}

  alias OpenAgents.Forge.{Repos, WAL}

  alias OpenAgents.{Analytics, Audit, Repo}

  alias OpenAgents.Machines.Machine

  alias OpenAgents.Repositories.{

    )

  end

  @doc "Returns the first repository path in the user's workspace, or `nil`."

  def sidebar_repository_path(%User{id: user_id}) do

    case Repo.one(

           from repository in Repository,

             join: namespace in assoc(repository, :namespace),

             join: membership in Membership,

             on:

               membership.repository_id == repository.id and membership.user_id == ^user_id and

                 membership.role in ^~w(owner maintainer contributor viewer),

             order_by: [asc: namespace.slug_key, asc: repository.name_key, asc: repository.id],

             limit: 1,

             select: {namespace.slug, repository.name}

         ) do

      {owner, name} -> "/#{owner}/#{name}"

      nil -> nil

    end

  end

  @doc "Delete a repository owned by `user`, including its durable and node-local Git data."

  def delete_owned_repository(owner, name, %User{} = user, options \\ [])

      when is_binary(owner) and is_binary(name) do

    with %Repository{} = repository <- owned_repository(owner, name, user) do

      result =

        :global.trans({{:forge_push, repository.storage_key}, self()}, fn ->

          delete_owned_repository_locked(repository, user)

        end)

      case result do

        {:ok, deleted} = success ->

          Analytics.capture("repository_deleted", Analytics.distinct_id(user), %{

            "repository_id" => deleted.id,

            "provisioning_kind" => deleted.provisioning_kind,

            "surface" => Keyword.get(options, :surface, "api")

          })

          success

        error ->

          error

      end

    else

      nil -> {:error, :not_found}

    end

  end

  defp owned_repository(owner, name, %User{id: user_id}) do

    owner_key = String.downcase(owner)

    name_key = String.downcase(name)

    Repo.one(

      from repository in repository_path_query(owner_key, name_key),

        join: membership in Membership,

        on:

          membership.repository_id == repository.id and membership.user_id == ^user_id and

            membership.role == "owner"

    )

  end

  defp delete_owned_repository_locked(repository, user) do

    Repo.transaction(fn ->

      locked_repository =

        Repo.one(

          from candidate in Repository,

            join: membership in Membership,

            on:

              membership.repository_id == candidate.id and membership.user_id == ^user.id and

                membership.role == "owner",

            where: candidate.id == ^repository.id,

            lock: "FOR UPDATE",

            select: candidate

        )

      if is_nil(locked_repository), do: Repo.rollback(:not_found)

      provisioning =

        Repo.one(

          from outbox in ProvisioningOutbox,

            where: outbox.repository_id == ^locked_repository.id,

            lock: "FOR UPDATE"

        )

      if provisioning && provisioning.state == "running", do: Repo.rollback(:repository_busy)

      with :ok <- WAL.delete_repo(locked_repository.storage_key),

           :ok <- delete_local_caches(locked_repository.storage_key) do

        Audit.record!(

          "repository.deleted",

          {:user, user.id},

          "repository",

          locked_repository.id,

          repository_id: locked_repository.id,

          metadata: %{

            "owner" => locked_repository.owner,

            "name" => locked_repository.name,

            "provisioning_kind" => locked_repository.provisioning_kind

          }

        )

        Repo.delete!(locked_repository)

      else

        {:error, reason} -> Repo.rollback({:storage_cleanup_failed, reason})

      end

    end)

  end

  defp delete_local_caches(storage_key) do

    [node() | Node.list()]

    |> Enum.uniq()

    |> Task.async_stream(

      fn target ->

        if target == node() do

          Repos.delete_repo(storage_key)

        else

          :erpc.call(target, Repos, :delete_repo, [storage_key], 30_000)

        end

      end,

      ordered: false,

      timeout: 31_000,

      on_timeout: :kill_task,

      max_concurrency: max(1, 1 + length(Node.list()))

    )

    |> Enum.reduce_while(:ok, fn

      {:ok, :ok}, :ok -> {:cont, :ok}

      {:ok, {:error, reason}}, :ok -> {:halt, {:error, reason}}

      {:exit, reason}, :ok -> {:halt, {:error, reason}}

    end)

  end

  def list_visible_repositories_page(

        %User{id: user_id},

        per_page,

    assigns =

      assigns

      |> assign(:agent_surfaces?, agent_surfaces?(assigns[:current_scope]))

      |> assign(:repository_path, assigns.current_scope.sidebar_repository_path)

    ~H"""

    <aside id="sidebar" class="sidebar hidden lg:flex">

          patchable={false}

        />

        <Layouts.sidebar_link

          path={~p"/OpenAgentsInc/openagents.com/issues"}

          :if={@repository_path}

          path={@repository_path <> "/issues"}

          label="Issues"

          icon="bug"

          patchable={false}

        />

        <Layouts.sidebar_link

          path={~p"/OpenAgentsInc/openagents.com/projects"}

          :if={@repository_path}

          path={@repository_path <> "/projects"}

          label="Projects"

          icon="folder"

          patchable={false}

    Ecto.NoResultsError -> render_error(conn, :not_found)

  end

  def delete(conn, %{"owner" => owner, "repo" => name}) do

    case Repositories.delete_owned_repository(owner, name, conn.assigns.current_user,

           surface: "api"

         ) do

      {:ok, _repository} -> send_resp(conn, :no_content, "")

      {:error, reason} -> render_error(conn, reason)

    end

  end

  defp render_repository(conn, repository, user, replay_state) do

    status = if repository.lifecycle_state == "ready", do: :created, else: :accepted

    do:

      error(conn, :conflict, "repository_name_conflict", "Repository name is unavailable", "name")

  defp render_error(conn, :repository_busy),

    do:

      error(

        conn,

        :conflict,

        "repository_busy",

        "Repository provisioning is still running. Try again after it finishes"

      )

  defp render_error(conn, {:storage_cleanup_failed, _reason}),

    do:

      error(

        conn,

        :service_unavailable,

        "repository_delete_failed",

        "Repository storage could not be deleted"

      )

  defp render_error(conn, :repository_quota_exceeded),

    do:

      error(

          icon: "code",

          route: "/repositories"

        },

        %{

          slug: "delete-repository",

          title: "Delete a repository",

          icon: "trash",

          route: "/repositories"

        },

        %{

          slug: "cli-command-reference",

          title: "CLI command reference",

  end

  @doc "Directory holding the Markdown sources."

  def source_dir, do: Application.app_dir(:openagents, "priv/docs")

  def source_dir do

    Application.get_env(

      :openagents,

      :docs_source_dir,

      Application.app_dir(:openagents, "priv/docs")

    )

  end

  @doc """

  Read and render one page.

    refs = if head, do: Browse.refs(repository), else: []

    delete_allowed? =

      Repositories.membership_role(repository, socket.assigns.current_user) == "owner"

    # A repository that is still provisioning is the one state this page cannot

    # render usefully, and it is also the one state that ends on its own. The

    # provisioner and the importer announce each transition, so the page hears

     |> assign(:branch_count, Enum.count(refs, &(&1.kind == :branch)))

     |> assign(:tag_count, Enum.count(refs, &(&1.kind == :tag)))

     |> assign(:open_issue_count, open_issue_count(repository))

     |> assign(:clone_url, RepositoryAccess.clone_url(repository))}

     |> assign(:clone_url, RepositoryAccess.clone_url(repository))

     |> assign(:delete_allowed?, delete_allowed?)

     |> assign(:delete_error, nil)

     |> assign(

       :delete_form,

       to_form(%{"confirmation" => ""}, as: :repository_delete)

     )}

  rescue

    Ecto.NoResultsError -> raise OpenAgentsWeb.PublicNotFoundError

  end

    end

  end

  @impl true

  def handle_event(

        "delete_repository",

        %{"repository_delete" => %{"confirmation" => confirmation} = params},

        socket

      ) do

    expected = "#{socket.assigns.owner}/#{socket.assigns.repo}"

    if confirmation == expected do

      case Repositories.delete_owned_repository(

             socket.assigns.owner,

             socket.assigns.repo,

             socket.assigns.current_user,

             surface: "web"

           ) do

        {:ok, _repository} ->

          {:noreply,

           socket

           |> put_flash(:info, "Repository deleted.")

           |> push_navigate(to: ~p"/repositories")}

        {:error, :repository_busy} ->

          {:noreply,

           assign(

             socket,

             :delete_error,

             "Repository provisioning is still running. Try again after it finishes."

           )}

        {:error, _reason} ->

          {:noreply,

           assign(socket, :delete_error, "OpenAgents could not delete this repository.")}

      end

    else

      {:noreply,

       socket

       |> assign(:delete_form, to_form(params, as: :repository_delete))

       |> assign(:delete_error, "Type #{expected} exactly to confirm deletion.")}

    end

  end

  defp short(sha), do: String.slice(sha, 0, 12)

  # The tab carries a count only when there is something to count, the way the

            </ol>

          </.card>

          <.card

            :if={@delete_allowed?}

            id="repository-danger-zone"

            variant={:danger}

            class="space-y-4"

          >

            <header>

              <h2>Delete repository</h2>

            </header>

            <p class="text-sm text-muted-foreground">

              This permanently deletes the repository, its Git history, issues, projects, and

              import records. You cannot undo this action.

            </p>

            <.alert

              :if={@delete_error}

              id="repository-delete-error"

              variant={:danger}

              title="Repository was not deleted"

            >

              {@delete_error}

            </.alert>

            <.form

              for={@delete_form}

              id="repository-delete-form"

              phx-submit="delete_repository"

              class="space-y-3"

            >

              <.input

                field={@delete_form[:confirmation]}

                type="text"

                label={"Type #{@owner}/#{@repo} to confirm"}

                autocomplete="off"

                required

              />

              <.button

                id="repository-delete-submit"

                type="submit"

                variant={:destructive}

                phx-disable-with="Deleting repository…"

              >

                Delete repository

              </.button>

            </.form>

          </.card>

          <:about>

            <.repo_about description={@repository.description}>

              <%!-- The file that is actually there, under the name it actually

        >

          <:column title="Product">

            <.link navigate={~p"/docs"}>Documentation</.link>

            <.link navigate={~p"/OpenAgentsInc/openagents.com/issues"}>Issues</.link>

            <.link navigate={~p"/docs/issues"}>Issues</.link>

          </:column>

          <:column title="Transparency">

            <.link navigate={~p"/changelog"}>Changelog</.link>

    get "/user/repos", RepositoryController, :index

    post "/user/repos", RepositoryController, :create_user

    post "/orgs/:org/repos", RepositoryController, :create_organization

    delete "/repos/:owner/:repo", RepositoryController, :delete

    post "/user/repos/imports", RepositoryImportController, :create_user

    post "/orgs/:org/repos/imports", RepositoryImportController, :create_organization

    get "/repository-imports/:id", RepositoryImportController, :show

  import Plug.Conn

  alias OpenAgents.Accounts

  alias OpenAgents.{Accounts, Repositories}

  @session_key "user_id"

  # The scope is the user, plus the answers the layout needs on every render

  # and must not re-ask for. Resolved once here, at mount.

  defp scope(user) do

    %{user | agent_surfaces?: OpenAgents.Conversations.user_has_messages?(user)}

  defp scope(user, params) do

    repository_path =

      case params do

        %{"owner" => owner, "repo" => repository}

        when is_binary(owner) and is_binary(repository) ->

          "/#{owner}/#{repository}"

        _other ->

          Repositories.sidebar_repository_path(user)

      end

    %{

      user

      | agent_surfaces?: OpenAgents.Conversations.user_has_messages?(user),

        sidebar_repository_path: repository_path

    }

  end

  def on_mount(:mount_current_user, _params, session, socket) do

  def on_mount(:mount_current_user, params, session, socket) do

    socket = assign_sidebar_sections(socket, session)

    with user_id when is_binary(user_id) <- session[@session_key],

      {:cont,

       socket

       |> Phoenix.Component.assign(:current_user, user)

       |> Phoenix.Component.assign(:current_scope, scope(user))}

       |> Phoenix.Component.assign(:current_scope, scope(user, params))}

    else

      _missing_or_inactive ->

        {:cont,

    end

  end

  def on_mount(:ensure_authenticated, _params, session, socket) do

  def on_mount(:ensure_authenticated, params, session, socket) do

    socket = assign_sidebar_sections(socket, session)

    with user_id when is_binary(user_id) <- session[@session_key],

      {:cont,

       socket

       |> Phoenix.Component.assign(:current_user, user)

       |> Phoenix.Component.assign(:current_scope, scope(user))

       |> Phoenix.Component.assign(:current_scope, scope(user, params))

       |> Phoenix.LiveView.attach_hook(

         :active_user_guard,

         :handle_event,

    "import_organization_repository": "POST /api/v3/orgs/{org}/repos/imports",

    "list_repositories": "GET /api/v3/user/repos",

    "get_repository": "GET /api/v3/repos/{owner}/{repo}",

    "delete_repository": "DELETE /api/v3/repos/{owner}/{repo}",

    "get_repository_import": "GET /api/v3/repository-imports/{id}",

    "create_device_authorization": "POST /api/v3/device/authorizations",

    "poll_device_authorization": "POST /api/v3/device/authorizations/token"

      "not_found",

      "repository_quota_exceeded",

      "repository_name_conflict",

      "repository_busy",

      "repository_delete_failed",

      "slow_down",

      "source_namespace_mismatch",

      "source_repository_not_accessible"

The CLI retrieves the clone URL from the API and starts standard Git.

## Delete a repository

```text

openagents repo delete [OWNER/REPOSITORY] --yes

openagents repo delete --repo OWNER/REPOSITORY --yes

```

The command permanently deletes a repository you own, including its Git

history, issues, projects, and import records. You must pass `--yes`. When you

omit the repository, the CLI infers it from an exact OpenAgents `origin`

remote on the selected API origin.

## Use JSON in noninteractive processes

With `--json`, stdout contains machine-readable output. Human progress and

# Delete a repository

You can permanently delete a repository you own from the website, REST API,

or CLI. Maintainers, contributors, and viewers cannot delete a repository.

Deletion removes the Git history, issues, projects, labels, milestones,

memberships, import receipt, and provisioning records. You cannot undo it.

## Delete from the website

1. Open the repository.

2. Find **Delete repository** near the bottom of the **Code** page.

3. Type the full `OWNER/REPOSITORY` name shown in the confirmation field.

4. Select **Delete repository**.

If provisioning is actively writing repository data, OpenAgents asks you to

try again after that operation finishes.

## Delete with the CLI

Pass `--yes` as explicit confirmation:

```sh

openagents repo delete OWNER/REPOSITORY --yes

```

You can run the same one-time command through `npx`:

```sh

npx --yes @openagentsinc/cli@latest repo delete OWNER/REPOSITORY --yes

```

The command also supports `--repo OWNER/REPOSITORY`. When you omit the name,

the CLI infers it from an exact OpenAgents `origin` remote.

## Delete with the REST API

Send an API token with the `forge:write` scope:

```sh

curl --request DELETE \

  --header "Authorization: Bearer $OPENAGENTS_TOKEN" \

  https://openagents.com/api/v3/repos/OWNER/REPOSITORY

```

Success returns `204 No Content`. OpenAgents returns `404 Not Found` when the

repository does not exist or you are not its owner.

- Import a GitHub repository as a one-time copy.

- List and inspect repositories that you can access.

- Clone repositories and configure Git authentication.

- Delete a repository you own with explicit confirmation.

- Push, pull, and fetch with standard Git.

- Use JSON output and stable exit codes in scripts and agents.

The current release does not provide pull requests, repository deletion,

continuous GitHub mirroring, SSH transport, rulesets, or a self-update command.

The current release does not provide pull requests, continuous GitHub

mirroring, SSH transport, rulesets, or a self-update command.

## Choose how to run the CLI

- Select **Import from GitHub** to copy one GitHub repository.

- Open a repository to see its clone URL, lifecycle state, code, Issues,

  Projects, and import receipt when applicable.

- Open a repository's **Delete repository** section to permanently delete a

  repository you own.

## Follow a common terminal workflow

- [Create a repository](/docs/create-repository)

- [Import from GitHub](/docs/import-github)

- [Clone, push, and pull](/docs/clone-push-pull)

- [Delete a repository](/docs/delete-repository)

- [CLI command reference](/docs/cli-command-reference)

GET    /api/v3/user

GET    /api/v3/user/repos

GET    /api/v3/repos/:owner/:repo

DELETE /api/v3/repos/:owner/:repo

POST   /api/v3/user/repos

POST   /api/v3/orgs/:org/repos

POST   /api/v3/user/repos/imports

[`openagents.repositories.v1` contract](/api/contracts/repositories-v1.json)

defines request authority, lifecycle states, pagination, and stable error

codes. The [OpenAgents CLI](/docs/openagents-cli) implements this contract.

Only a repository owner can delete it. A successful deletion returns

`204 No Content`.

## Comments

    end

  end

  describe "delete_repo/1" do

    test "removes the index and every immutable object for one repository" do

      payload = "repository payload"

      assert {:ok, key} = WAL.put_entry(@repo, 0, payload)

      index =

        WAL.new_index()

        |> WAL.append_entry(%{

          "seq" => 0,

          "object" => key,

          "refs" => %{"refs/heads/main" => String.duplicate("a", 40)},

          "principal" => "test",

          "pushed_at" => DateTime.utc_now() |> DateTime.to_iso8601()

        })

      assert {:ok, _generation} = WAL.cas_index(@repo, :none, index)

      assert :ok = WAL.delete_repo(@repo)

      assert {:error, :not_found} = WAL.read_index(@repo)

      assert {:error, :not_found} = WAL.get_entry(@repo, key)

      assert :ok = WAL.delete_repo(@repo)

    end

  end

  describe "digest-addressed artifacts" do

    test "round trips only under the payload's full SHA-256" do

      payload = :crypto.strong_rand_bytes(512)

        assert {:error, :invalid_repo} = WAL.put_entry(bad, 0, "x")

        assert {:error, :invalid_repo} = WAL.put_entry_file(bad, 0, "/tmp/entry")

        assert {:error, :invalid_repo} = WAL.get_entry(bad, "entries/00000000-0123456789ab")

        assert {:error, :invalid_repo} = WAL.delete_repo(bad)

        assert {:error, :invalid_repo} =

                 WAL.get_entry_file(bad, "entries/00000000-0123456789ab", "/tmp/entry")

               OpenAgents.Forge.WAL.Gcs.cas_index(@repo, :none, WAL.new_index())

      assert {:error, :not_configured} = OpenAgents.Forge.WAL.Gcs.put_entry(@repo, 0, "x")

      assert {:error, :not_configured} = OpenAgents.Forge.WAL.Gcs.delete_repo(@repo)

      assert {:error, :not_configured} =

               OpenAgents.Forge.WAL.Gcs.put_entry_file(@repo, 0, "/tmp/entry")

  use OpenAgentsWeb.ConnCase, async: false

  alias OpenAgents.ApiTokens

  alias OpenAgents.Forge.{Repos, WAL}

  alias OpenAgents.Repositories

  test "POST /api/v3/user/repos creates in the authenticated GitHub namespace", %{conn: conn} do

             |> json_response(422)

  end

  test "DELETE /api/v3/repos/:owner/:repo removes an owned repository and its storage", %{

    conn: conn

  } do

    configure_repository_storage("repository-api-delete")

    owner = github_user("repository-api-delete-owner", "delete-owner")

    assert {:ok, repository, :created} =

             Repositories.create_user_repository(

               owner,

               %{name: "delete-me", visibility: "private"},

               "delete-repository"

             )

    mark_ready(repository)

    assert {:ok, _generation} = WAL.cas_index(repository.storage_key, :none, WAL.new_index())

    bare_path = Repos.ensure_repo!(repository.storage_key)

    response =

      conn

      |> authorize(owner)

      |> delete("/api/v3/repos/delete-owner/delete-me")

    assert response.status == 204

    assert response.resp_body == ""

    assert_raise Ecto.NoResultsError, fn ->

      Repositories.get_by_path!("delete-owner", "delete-me")

    end

    assert {:error, :not_found} = WAL.read_index(repository.storage_key)

    refute File.exists?(bare_path)

  end

  test "DELETE /api/v3/repos/:owner/:repo permits only repository owners", %{conn: conn} do

    owner = github_user("repository-api-delete-authorization-owner", "protected-owner")

    maintainer = github_user("repository-api-delete-authorization-maintainer")

    assert {:ok, repository, :created} =

             Repositories.create_user_repository(

               owner,

               %{name: "protected-repository", visibility: "private"},

               "protected-repository"

             )

    mark_ready(repository)

    assert {:ok, _membership} = Repositories.add_member(repository, maintainer, "maintainer")

    assert %{"code" => "not_found"} =

             conn

             |> authorize(maintainer)

             |> delete("/api/v3/repos/protected-owner/protected-repository")

             |> json_response(404)