Remove implicit repository routing

`list_visible_repositories/1` held had already lost the `ready` half and
disagreed with the paged read about the same repository; there is one copy now.

Amended 2026-08-22 (explicit issue and project repository scope): production
contexts accept a repository or a resource that already carries its repository
identity. No context function selects a default repository or grants membership
as a side effect. The Projects V2 API uses
`/api/v3/repos/:owner/:repo/projectsV2`; every project, item, and field query
includes that repository. Optional bearer authentication lets a member read a
private repository's issues and projects, while anonymous readers and
nonmembers receive `404 Not Found`. Every write still requires `forge:write`
and a writable membership in the same repository.

Evidence: `OpenAgents.Repositories`, `OpenAgents.Repositories.Provisioner`,
`OpenAgents.Repositories.Importer`, `OpenAgents.Forge.GitHTTP`,
`test/openagents/repository_lifecycle_test.exs`,
`test/openagents/repositories/provisioner_test.exs`,
`test/openagents_web/controllers/repository_controller_test.exs`,
`test/openagents_web/controllers/issue_controller_test.exs`,
`test/openagents_web/controllers/project_controller_test.exs`,
`test/openagents/issues_workspace_test.exs`,
`test/openagents_web/live/issue_workspace_live_test.exs`,
`test/openagents_web/live/project_workspace_live_test.exs`, and


**Date:** 2026-08-21
**Commits measured:** `81e4c25eb5b5` (`openagents/main`, the forge) for the API; `5bd0061e4f6e` in the `openagents` monorepo for `packages/openagents-cli` (package version `0.1.7`)
**Status:** Stage 1 shipped on 2026-08-21 as `@openagentsinc/cli@0.2.1`; see section 5. Everything else below describes the surface as measured, unchanged.
**Status:** Stages 1, 2, and 7 shipped. Stage 1 added `openagents api` in `@openagentsinc/cli@0.2.1`. Stages 2 and 7 added optional-bearer issue reads and repository-scoped Projects V2 routes on 2026-08-22. Historical measurements below retain the original findings.
**Question:** Does the CLI only cover repository upload? What of the Issues and Projects API does it reach? Should that coverage be generated from an OpenAPI document instead of hand-written? What is the fastest honest path to managing issues and projects from a terminal?
**Method:** direct reading of `lib/openagents_web/router.ex`, every controller it routes to under `/api/v3`, the contexts behind them (`lib/openagents/issues.ex`, `labels.ex`, `milestones.ex`, `projects.ex`, `repositories.ex`), the auth plugs, `lib/openagents_web/route_authority.ex`, `priv/api-contracts/repositories-v1.json` and its controller and test, and `docs/openagents-cli/`; plus direct reading of all 21 source files in the `openagents` monorepo at `packages/openagents-cli/src/` and its tests. The CLI lives in a different repository, so every CLI citation names it. Claims that neither repository can settle are in section 7 with the command that would settle them.



## 0. Summary

> **Update, 2026-08-22:** The server now resolves Projects V2 through
> `/repos/:owner/:repo/projectsV2`, applies the named repository's read and
> write policy to every project operation, and supports authenticated reads of
> private issues. The `initial_repository!/0` and `initial_path/0` shortcuts no
> longer exist. The findings below describe the pre-remediation surface.

The owner is right. The CLI is repository-shaped and reaches **none** of the Issues and Projects API.

The numbers are clean. The router exposes **50 routes under `/api/v3`** (`lib/openagents_web/router.ex:229`, `:253`, `:259`). The CLI calls **11 of them** — the authenticated user, repository create, list, view, delete, the two import routes, import status, and the two device-authorization routes. Those 11 are exactly the routes named in the hand-written contract document at `priv/api-contracts/repositories-v1.json:18`. The other **39 routes — every issue, comment, label, milestone, assignee, and project endpoint — have no CLI surface at all**, and the CLI's own documentation says so: `docs/openagents-cli/command-reference.md:3` scopes the tool to "authentication and hosted repositories", and `:171` lists a generic API command among the things the release does not provide.


### Stage 7 — Make projects addressable, then build project commands (this repository, then CLI; large)

**Shipped on 2026-08-22.** Projects now use repository-shaped routes and no
production context selects a default repository. The generic `openagents api`
command can address the resulting project surface; dedicated project commands
remain future CLI work.

Unpin the project surface from `Repositories.initial_repository!()` (`projects.ex:26`, `:131`), make `ProjectController.create` honor its own `:owner` segment instead of resolving `Repositories.initial_path()` (`project_controller.ex:21`), reconcile `POST /api/v3/:owner/projectsV2` with the `/users/:username/projectsV2` shape every other project route uses (`router.ex:290`), and give the project reads a visibility predicate. Only then are there project commands worth writing. **Size:** large, and it is genuinely a redesign rather than a port.

### What makes issue management usable this week versus complete

1. **The coverage floor gates nothing.** `mix.exs` declares `threshold: 83.0`, and `ops/ci/coverage.sh` correctly unions default and cluster-only passes, but neither `mix precommit` nor `gate.sh` invokes the script. Add a coverage stage to the gate.
2. **No hosted CI.** Verification depends entirely on developers running the pre-push hook locally; nothing remote proves a push passed the gate. This is documented as deliberate, and the receipt system makes external attestation easy to add later — but today the guarantee is trust-based.
3. **Contexts without same-name tests.** Verified list includes `Audit`, `Mailer`, `BuildInfo`, `ComputerAgentJobs`, `ReleaseState`, `TurnRecovery` (covered indirectly), among others. `Audit` appears in only one indirect test; `Mailer` has zero test references.
4. **A known cross-user authorization gap is pinned as expected behavior.** Per the coverage audit, `ProjectController` ignores the `:username` segment, so a project owned by alice is readable and writable at `/users/bob/projectsV2/:n`. Tests deliberately document the divergence instead of fixing it. Decide: either implement username scoping or remove the segment from the contract.
4. **Resolved on 2026-08-22: project routes previously ignored username authority.** Projects now use `/repos/:owner/:repo/projectsV2`, and the repository path controls read and write authority for every project, item, and field operation.
5. **Test-rule violations.** Seven bare `Process.sleep/1` call sites contradict the repository's own testing rules (`coding_job_test.exs:118`, `computer_tools_test.exs:43`, `registry_and_runner_test.exs:39`, `builder_test.exs:266`, `ra_cluster_test.exs:160` and neighbors). Replace with monitors or the shared `eventually` helper.
6. **Async tagging is inconsistent**: 76 files tagged `async: true`, 109 tagged false, 48 untagged. Some serialization is likely habitual rather than required; audit and tag deliberately.



```sh
REPOSITORY_API=https://openagents.com/api/v3/repos/OpenAgentsInc/openagents.com
USER_LOGIN=$(curl -fsS "https://openagents.com/api/v3/user" \
  -H "Authorization: Bearer $TOKEN" | jq -r '.login')

curl -fsS -X POST "$REPOSITORY_API/milestones" \
  -H "Authorization: Bearer $TOKEN" \

  -d '{"title": "Backlog hygiene", "description": "First triage sweep"}'

PROJECT_NUMBER=$(curl -fsS -X POST \
  "https://openagents.com/api/v3/$USER_LOGIN/projectsV2" \
  "$REPOSITORY_API/projectsV2" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"title": "openagents.com roadmap"}' | jq -r '.number')

curl -fsS -X POST \
  "https://openagents.com/api/v3/users/$USER_LOGIN/projectsV2/$PROJECT_NUMBER/fields" \
  "$REPOSITORY_API/projectsV2/$PROJECT_NUMBER/fields" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name": "Status", "data_type": "single_select", "options": {"values": ["To Do", "In Progress", "Done"]}}'
```

The project belongs to the GitHub login tied to your token. Add high-signal
The project belongs to the repository in `REPOSITORY_API`. Add high-signal
issues to the board and set their `Status` value through the project items API.

### Label vocabulary


| Method | Path |
| --- | --- |
| `GET` | `/users/{username}/projectsV2` |
| `POST` | `/{owner}/projectsV2` |
| `GET` | `/users/{username}/projectsV2/{project_number}` |
| `GET, POST` | `/users/{username}/projectsV2/{project_number}/items` |
| `PATCH` | `/users/{username}/projectsV2/{project_number}/items/{item_id}` |
| `GET` | `/users/{username}/projectsV2/{project_number}/fields` |
| `GET, POST` | `/repos/{owner}/{repo}/projectsV2` |
| `GET` | `/repos/{owner}/{repo}/projectsV2/{project_number}` |
| `GET, POST` | `/repos/{owner}/{repo}/projectsV2/{project_number}/items` |
| `PATCH` | `/repos/{owner}/{repo}/projectsV2/{project_number}/items/{item_id}` |
| `GET, POST` | `/repos/{owner}/{repo}/projectsV2/{project_number}/fields` |

The project-creation endpoint is an OpenAgents extension because the comparable
GitHub Projects V2 creation workflow is not supplied by the assessed REST


These are current measured behaviors:

- `/api/v3` public reads and authenticated writes use separate pipelines.
- `/api/v3` anonymous and optional-bearer reads and authenticated writes use
  separate pipelines.
  Writes require an expiring digest-only `oa_pat_…` bearer with exact
  `forge:write` scope. An authenticated person creates and revokes credentials
  at `/settings/api-tokens`; plaintext is shown once.

  assignee links, milestones, and project items.
- Issue and milestone numbers are repository-local. Project numbers are also
  repository-local for the repository-shaped LiveView surface.
- Project show, item, update-item, and field actions enforce the username in the
  route. The user-shaped Projects V2 subset is limited to the explicit initial
  repository because those compatibility URLs contain no repository segment.
- Project list, show, item, update-item, and field actions resolve the repository
  from the route. Public repositories allow anonymous reads. Private reads and
  every write require membership in that repository.
- Assignee reads return active repository members with writable roles, and
  issue assignment accepts only those members.


  @doc "How many issues one index page shows."
  def per_page, do: @issues_per_page

  def list_issues(opts \\ []) when is_list(opts),
    do: list_issues(Repositories.initial_repository!(), opts)

  def list_issues(%Repository{id: repository_id}, opts) when is_list(opts) do
  def list_issues(%Repository{id: repository_id}, opts \\ []) when is_list(opts) do
    repository_id
    |> issue_query(opts)
    |> order_by([issue], desc: issue.inserted_at, desc: issue.id)

    |> maybe_filter_search(Keyword.get(opts, :q))
  end

  def get_issue!(id), do: get_issue!(Repositories.initial_repository!(), id)

  def get_issue!(%Repository{id: repository_id}, id) do
    Repo.get_by!(Issue, id: id, repository_id: repository_id)
  end

  def get_issue_by_number!(number) when is_integer(number),
    do: get_issue_by_number!(Repositories.initial_repository!(), number)

  def get_issue_by_number!(%Repository{id: repository_id}, number) when is_integer(number),
    do: Repo.get_by!(Issue, repository_id: repository_id, number: number)


    )
  end

  def create_issue(attrs \\ %{}),
    do: create_issue(Repositories.initial_repository!(), attrs, nil)

  def create_issue(%Repository{} = repository, attrs),
    do: create_issue(repository, attrs, nil)


    end
  end

  def change_issue(%Issue{} = issue, attrs \\ %{}) do
    attrs =
      if is_nil(issue.repository_id) do
        attrs
        |> to_string_map()
        |> Map.put("repository_id", Repositories.initial_repository!().id)
      else
        attrs
      end
  def change_issue(%Repository{id: repository_id}, %Issue{} = issue, attrs) do
    attrs = attrs |> to_string_map() |> Map.put("repository_id", repository_id)
    Issue.changeset(issue, attrs)
  end

  def change_issue(%Issue{repository_id: repository_id} = issue, attrs \\ %{})
      when not is_nil(repository_id) do
    Issue.changeset(issue, attrs)
  end


    |> Repo.all()
  end

  def list_comments(issue_id) do
    issue = get_issue!(issue_id)
    list_comments(issue)
  end

  def get_comment!(id), do: get_comment!(Repositories.initial_repository!(), id)

  def get_comment!(%Repository{id: repository_id}, id) do
    Repo.get_by!(Comment, id: id, repository_id: repository_id)
  end

    )
  end

  def create_comment(attrs \\ %{}) do
  def create_comment(attrs) when is_map(attrs) do
    normalized = to_string_map(attrs)

    case Map.fetch(normalized, "issue_id") do
      {:ok, issue_id} ->
        issue = get_issue!(issue_id)
        create_comment(issue, normalized, nil)
        case Repo.get(Issue, issue_id) do
          %Issue{} = issue -> create_comment(issue, normalized, nil)
          nil -> invalid_comment(normalized)
        end

      :error ->
        now = DateTime.utc_now() |> DateTime.truncate(:second)

        %Comment{}
        |> Comment.changeset(
          normalized
          |> Map.put("repository_id", Repositories.initial_repository!().id)
          |> Map.put_new("created_at", now)
          |> Map.put_new("updated_at", now)
        )
        |> Ecto.Changeset.apply_action(:insert)
        invalid_comment(normalized)
    end
  end

  defp invalid_comment(attrs) do
    now = DateTime.utc_now() |> DateTime.truncate(:second)

    %Comment{}
    |> Comment.changeset(
      attrs
      |> Map.put_new("created_at", now)
      |> Map.put_new("updated_at", now)
    )
    |> Ecto.Changeset.apply_action(:insert)
  end

  def create_comment(%Issue{} = issue, attrs, author \\ nil)
      when is_nil(author) or is_struct(author, User) do
    normalized =

  alias OpenAgents.Accounts.User
  alias OpenAgents.Analytics
  alias OpenAgents.Repo
  alias OpenAgents.Repositories
  alias OpenAgents.Repositories.Repository

  alias OpenAgents.Labels.Label

      [%Label{}, ...]

  """
  def list_labels, do: list_labels(Repositories.initial_repository!())

  def list_labels(%Repository{id: repository_id}) do
    Label
    |> where(repository_id: ^repository_id)

      ** (Ecto.NoResultsError)

  """
  def get_label!(id), do: get_label!(Repositories.initial_repository!(), id)

  def get_label!(%Repository{id: repository_id}, id) do
    Repo.get_by!(Label, id: id, repository_id: repository_id)
  end

  def get_label_by_name!(name) when is_binary(name) do
    get_label_by_name!(Repositories.initial_repository!(), name)
  end

  def get_label_by_name!(%Repository{id: repository_id}, name) when is_binary(name) do
    Repo.get_by!(Label, repository_id: repository_id, name: URI.decode(name))
  end

      {:error, %Ecto.Changeset{}}

  """
  def create_label(attrs), do: create_label(Repositories.initial_repository!(), attrs, nil)

  def create_label(%Repository{} = repository, attrs, actor \\ nil)
      when is_nil(actor) or is_struct(actor, User) do
    attrs =

  alias OpenAgents.Analytics
  alias OpenAgents.Issues.Issue
  alias OpenAgents.Repo
  alias OpenAgents.Repositories
  alias OpenAgents.Repositories.Repository

  alias OpenAgents.Milestones.Milestone

      [%Milestone{}, ...]

  """
  def list_milestones, do: list_milestones(Repositories.initial_repository!())

  def list_milestones(%Repository{id: repository_id}) do
    Milestone
    |> where(repository_id: ^repository_id)

      ** (Ecto.NoResultsError)

  """
  def get_milestone!(id), do: get_milestone!(Repositories.initial_repository!(), id)

  def get_milestone!(%Repository{id: repository_id}, id) do
    Milestone
    |> where(id: ^id, repository_id: ^repository_id)

    |> Repo.one!()
  end

  def get_milestone_by_number!(number) when is_integer(number),
    do: get_milestone_by_number!(Repositories.initial_repository!(), number)

  def get_milestone_by_number!(%Repository{id: repository_id}, number) when is_integer(number) do
    Milestone
    |> where(repository_id: ^repository_id, number: ^number)

      {:error, %Ecto.Changeset{}}

  """
  def create_milestone(attrs \\ %{}),
    do: create_milestone(Repositories.initial_repository!(), attrs, nil)

  def create_milestone(%Repository{} = repository, attrs, actor \\ nil)
      when is_nil(actor) or is_struct(actor, User) do
    normalized = for {k, v} <- attrs, into: %{}, do: {to_string(k), v}


  alias OpenAgents.ProjectItems.ProjectItem
  alias OpenAgents.Projects.Project
  alias OpenAgents.Repositories
  alias OpenAgents.Repositories.Repository

  @doc """
  Returns the list of project_items.

      [%ProjectItem{}, ...]

  """
  def list_project_items do
    repository_id = Repositories.initial_repository!().id
  def list_project_items(%Repository{id: repository_id}) do
    Repo.all(from item in ProjectItem, where: item.repository_id == ^repository_id)
  end


      ** (Ecto.NoResultsError)

  """
  def get_project_item!(id) do
    repository_id = Repositories.initial_repository!().id
  def get_project_item!(%Repository{id: repository_id}, id) do
    Repo.get_by!(ProjectItem, id: id, repository_id: repository_id)
  end


      {:error, %Ecto.Changeset{}}

  """
  def create_project_item(attrs) do
  def create_project_item(%Repository{} = repository, attrs) do
    attrs = for {key, value} <- attrs, into: %{}, do: {to_string(key), value}
    repository_id = repository_id_for(Map.get(attrs, "project_id"))
    repository_id = repository_id_for(repository, Map.get(attrs, "project_id"))

    %ProjectItem{}
    |> ProjectItem.changeset(Map.put(attrs, "repository_id", repository_id))

    ProjectItem.changeset(project_item, attrs)
  end

  defp repository_id_for(nil), do: Repositories.initial_repository!().id
  defp repository_id_for(%Repository{id: repository_id}, nil), do: repository_id

  defp repository_id_for(project_id) do
    case Repo.get(Project, project_id) do
  defp repository_id_for(%Repository{id: repository_id}, project_id) do
    case Repo.get_by(Project, id: project_id, repository_id: repository_id) do
      %Project{repository_id: repository_id} -> repository_id
      nil -> Repositories.initial_repository!().id
      nil -> repository_id
    end
  end
end

  alias OpenAgents.Repositories
  alias OpenAgents.Repositories.Repository

  def list_projects, do: list_projects(Repositories.initial_repository!())

  def list_projects(%Repository{id: repository_id}) do
    Project
    |> where(repository_id: ^repository_id)

    |> Repo.all()
  end

  def list_projects_by_owner(username) when is_binary(username) do
    repository_id = Repositories.initial_repository!().id

    Repo.all(
      from project in Project,
        where:
          project.repository_id == ^repository_id and
            fragment("lower(?)", project.owner) == ^String.downcase(username),
        order_by: [asc: project.number]
    )
  end

  @projects_per_page 25

  @doc "How many projects one workspace-wide page shows."

    )
  end

  def get_project!(id), do: get_project!(Repositories.initial_repository!(), id)

  def get_project!(%Repository{id: repository_id}, id) do
    Repo.get_by!(Project, id: id, repository_id: repository_id)
  end

  def get_project_by_number!(number) when is_integer(number),
    do: get_project_by_number!(Repositories.initial_repository!(), number)

  def get_project_by_number!(%Repository{id: repository_id}, number) when is_integer(number),
    do: Repo.get_by!(Project, repository_id: repository_id, number: number)


    )
  end

  def get_project_by_owner_and_number!(username, number) when is_integer(number) do
    repository_id = Repositories.initial_repository!().id

    Repo.one!(
      from project in Project,
        where:
          project.repository_id == ^repository_id and
            fragment("lower(?)", project.owner) == ^String.downcase(username) and
            project.number == ^number
    )
  end

  def create_project(attrs \\ %{}),
    do: create_project(Repositories.initial_repository!(), attrs, nil)

  def create_project(%Repository{} = repository, attrs),
    do: create_project(repository, attrs, nil)



  def delete_project(%Project{} = project), do: Repo.delete(project)

  def change_project(%Project{} = project, attrs \\ %{}) do
    attrs =
      if is_nil(project.repository_id) do
        attrs
        |> to_string_map()
        |> Map.put("repository_id", Repositories.initial_repository!().id)
      else
        attrs
      end

  def change_project(%Repository{id: repository_id}, %Project{} = project, attrs) do
    attrs = attrs |> to_string_map() |> Map.put("repository_id", repository_id)
    Project.changeset(project, attrs)
  end

  def list_project_items(project_id) when is_integer(project_id) do
    project = get_project!(project_id)
    list_project_items(project)
  def change_project(%Project{repository_id: repository_id} = project, attrs \\ %{})
      when not is_nil(repository_id) do
    Project.changeset(project, attrs)
  end

  def list_project_items(%Project{id: project_id, repository_id: repository_id}) do

    |> Repo.all()
  end

  def get_project_item!(id) do
    repository = Repositories.initial_repository!()
    Repo.get_by!(ProjectItem, id: id, repository_id: repository.id)
  end

  def get_project_item!(%Project{id: project_id, repository_id: repository_id}, id) do
    Repo.get_by!(ProjectItem,
      id: id,

    )
  end

  def get_project_item_by_owner!(username, project_number, item_id) do
    repository_id = Repositories.initial_repository!().id

    Repo.one!(
      from item in ProjectItem,
        join: project in Project,
        on:
          project.id == item.project_id and project.repository_id == item.repository_id and
            project.number == ^project_number,
        where:
          item.repository_id == ^repository_id and item.id == ^item_id and
            fragment("lower(?)", project.owner) == ^String.downcase(username)
    )
  end

  def create_project_item(attrs, project, actor \\ nil)

  def create_project_item(attrs, project_id, actor)
      when is_integer(project_id) do
    project = get_project!(project_id)
    create_project_item(attrs, project, actor)
  end

  def create_project_item(attrs, %Project{} = project, actor)
      when is_nil(actor) or is_struct(actor, User) do
    attrs = to_string_map(attrs)

    |> Repo.update()
  end

  def list_project_fields(project_id) when is_integer(project_id) do
    project = get_project!(project_id)
    list_project_fields(project)
  end

  def list_project_fields(%Project{id: project_id}) do
    ProjectField
    |> where(project_id: ^project_id)

    RepositoryImport
  }

  @initial_owner "OpenAgentsInc"
  @initial_name "openagents.com"
  @writable_roles ~w(owner maintainer contributor)
  @all_roles ~w(owner maintainer contributor viewer)
  @repository_namespace_limit 100

  # progress or provenance.
  @provisioning_assocs [:repository_import, :provisioning_outbox]

  def initial_path, do: {@initial_owner, @initial_name}

  def initial_repository! do
    get_by_path!(@initial_owner, @initial_name)
  end

  def get_by_path!(owner, name) when is_binary(owner) and is_binary(name) do
    owner_key = String.downcase(owner)
    name_key = String.downcase(name)


  def machine_access?(%Repository{}, _machine_id, _operation), do: false

  def ensure_initial_membership(%User{} = user) do
    add_member(initial_repository!(), user)
  end

  def writable?(%Repository{id: repository_id}, %User{id: user_id}) do
    Repo.exists?(
      from membership in Membership,


  def index(conn, %{"owner" => owner, "repo" => repo} = params) do
    state = Map.get(params, "state", "open")
    repository = Repositories.get_public_by_path!(owner, repo)
    repository = Repositories.get_visible_by_path!(owner, repo, conn.assigns[:current_user])
    issues = Issues.list_issues(repository, state: state)
    render(conn, :index, issues: issues, owner: owner, repo: repo)
  rescue

        "repo" => repo,
        "issue_number" => issue_number
      }) do
    issue = Issues.get_issue_by_path!(owner, repo, String.to_integer(issue_number))
    repository = Repositories.get_visible_by_path!(owner, repo, conn.assigns[:current_user])
    issue = Issues.get_issue_by_number!(repository, String.to_integer(issue_number))
    render(conn, :show, issue: issue, owner: owner, repo: repo)
  rescue
    Ecto.NoResultsError ->

  alias OpenAgents.Projects.Project
  alias OpenAgents.Repositories

  def index(conn, %{"username" => username}) do
    projects = Projects.list_projects_by_owner(username)

    render(conn, :index, projects: projects)
  def index(conn, %{"owner" => owner, "repo" => repo}) do
    repository = visible_repository!(conn, owner, repo)
    render(conn, :index, projects: Projects.list_projects(repository))
  rescue
    Ecto.NoResultsError -> not_found(conn)
  end

  def create(conn, %{"owner" => owner} = params) do
  def create(conn, %{"owner" => owner, "repo" => repo} = params) do
    user = conn.assigns.current_user

    if String.downcase(owner) != String.downcase(user.github_login) do
      raise Ecto.NoResultsError, queryable: Project
    end

    {repository_owner, repository_name} = Repositories.initial_path()

    repository =
      Repositories.get_writable_by_path!(repository_owner, repository_name, user)
    repository = Repositories.get_writable_by_path!(owner, repo, user)

    case Projects.create_project(repository, params, user) do
      {:ok, %Project{} = project} ->

    Ecto.NoResultsError -> not_found(conn)
  end

  def show(conn, %{"username" => username, "project_number" => project_number}) do
    project =
      Projects.get_project_by_owner_and_number!(username, String.to_integer(project_number))

  def show(conn, %{
        "owner" => owner,
        "repo" => repo,
        "project_number" => project_number
      }) do
    repository = visible_repository!(conn, owner, repo)
    project = Projects.get_project_by_number!(repository, parse_id!(project_number))
    render(conn, :show, project: project)
  rescue
    Ecto.NoResultsError ->
      conn
      |> put_status(:not_found)
      |> json(%{message: "Not Found"})
    Ecto.NoResultsError -> not_found(conn)
  end

  def items(conn, %{
        "username" => username,
        "owner" => owner,
        "repo" => repo,
        "project_number" => project_number
      }) do
    project =
      Projects.get_project_by_owner_and_number!(username, String.to_integer(project_number))

    items = Projects.list_project_items(project)
    render(conn, :items, items: items)
    repository = visible_repository!(conn, owner, repo)
    project = Projects.get_project_by_number!(repository, parse_id!(project_number))
    render(conn, :items, items: Projects.list_project_items(project))
  rescue
    Ecto.NoResultsError ->
      conn
      |> put_status(:not_found)
      |> json(%{message: "Not Found"})
    Ecto.NoResultsError -> not_found(conn)
  end

  def create_item(
        conn,
        %{
          "username" => username,
          "owner" => owner,
          "repo" => repo,
          "project_number" => project_number
        } = params
      ) do
    authorize_owner!(conn.assigns.current_user, username)

    project =
      Projects.get_project_by_owner_and_number!(username, String.to_integer(project_number))
    repository = writable_repository!(conn, owner, repo)
    project = Projects.get_project_by_number!(repository, parse_id!(project_number))

    case cast_issue_number(params["issue_number"]) do
    case cast_number(params["issue_number"]) do
      :error ->
        unprocessable(conn, %{issue_number: ["is invalid"]})


        end
    end
  rescue
    Ecto.NoResultsError ->
      conn
      |> put_status(:not_found)
      |> json(%{message: "Not Found"})
    Ecto.NoResultsError -> not_found(conn)
  end

  def update_item(
        conn,
        %{
          "username" => username,
          "owner" => owner,
          "repo" => repo,
          "project_number" => project_number,
          "item_id" => item_id
        } = params
      ) do
    authorize_owner!(conn.assigns.current_user, username)

    item =
      Projects.get_project_item_by_owner!(
        username,
        String.to_integer(project_number),
        String.to_integer(item_id)
      )
    repository = writable_repository!(conn, owner, repo)
    project = Projects.get_project_by_number!(repository, parse_id!(project_number))
    item = Projects.get_project_item!(project, parse_id!(item_id))

    if is_map(Map.get(params, "values", %{})) do
      case Projects.update_project_item(item, params) do

      unprocessable(conn, %{values: ["is invalid"]})
    end
  rescue
    Ecto.NoResultsError ->
      conn
      |> put_status(:not_found)
      |> json(%{message: "Not Found"})
    Ecto.NoResultsError -> not_found(conn)
  end

  def fields(conn, %{
        "username" => username,
        "owner" => owner,
        "repo" => repo,
        "project_number" => project_number
      }) do
    project =
      Projects.get_project_by_owner_and_number!(username, String.to_integer(project_number))

    fields = Projects.list_project_fields(project)
    render(conn, :fields, fields: fields)
    repository = visible_repository!(conn, owner, repo)
    project = Projects.get_project_by_number!(repository, parse_id!(project_number))
    render(conn, :fields, fields: Projects.list_project_fields(project))
  rescue
    Ecto.NoResultsError ->
      conn
      |> put_status(:not_found)
      |> json(%{message: "Not Found"})
    Ecto.NoResultsError -> not_found(conn)
  end

  def create_field(
        conn,
        %{
          "username" => username,
          "owner" => owner,
          "repo" => repo,
          "project_number" => project_number
        } = params
      ) do
    authorize_owner!(conn.assigns.current_user, username)

    project =
      Projects.get_project_by_owner_and_number!(username, String.to_integer(project_number))
    repository = writable_repository!(conn, owner, repo)
    project = Projects.get_project_by_number!(repository, parse_id!(project_number))

    attrs =
      params

    Ecto.NoResultsError -> not_found(conn)
  end

  defp cast_issue_number(number) when is_integer(number), do: {:ok, number}
  defp visible_repository!(conn, owner, repo) do
    Repositories.get_visible_by_path!(owner, repo, conn.assigns[:current_user])
  end

  defp writable_repository!(conn, owner, repo) do
    Repositories.get_writable_by_path!(owner, repo, conn.assigns.current_user)
  end

  defp cast_issue_number(number) when is_binary(number) do
  defp parse_id!(value) do
    case cast_number(value) do
      {:ok, number} -> number
      :error -> raise Ecto.NoResultsError, queryable: Project
    end
  end

  defp cast_number(number) when is_integer(number), do: {:ok, number}

  defp cast_number(number) when is_binary(number) do
    case Integer.parse(number) do
      {parsed, ""} -> {:ok, parsed}
      _ -> :error
    end
  end

  defp cast_issue_number(_other), do: :error
  defp cast_number(_other), do: :error

  defp unprocessable(conn, errors) do
    conn

    |> json(%{errors: errors})
  end

  defp authorize_owner!(user, username) do
    if String.downcase(user.github_login) != String.downcase(username) do
      raise Ecto.NoResultsError, queryable: Project
    end

    :ok
  end

  defp not_found(conn) do
    conn |> put_status(:not_found) |> json(%{message: "Not Found"})
  end

    |> stream(:repositories, repositories)
  end

  defp dashboard_repository(repositories) do
    {initial_owner, initial_name} = Repositories.initial_path()
  defp dashboard_repository(repositories),
    do: Enum.find(repositories, &(&1.lifecycle_state == "ready"))

    Enum.find(repositories, fn repository ->
      String.downcase(repository.namespace.slug) == String.downcase(initial_owner) and
        String.downcase(repository.name) == String.downcase(initial_name)
    end) || Enum.find(repositories, &(&1.lifecycle_state == "ready"))
  end

  defp repository_path(nil), do: Repositories.initial_path()
  defp repository_path(nil), do: {nil, nil}
  defp repository_path(repository), do: {repository.namespace.slug, repository.name}

  defp list_issues(nil, _state), do: []

          description="Purpose-built for planning and shipping issues. Designed for the agent era."
        >
          <:actions>
            <%= if @current_user do %>
              <.button
                id="home-cta-create"
                navigate={~p"/OpenAgentsInc/openagents.com/issues/new"}
                variant={:primary}
                size={:lg}
              >
                Create new issue
              </.button>
              <.button
                id="home-cta-browse"
                navigate={~p"/OpenAgentsInc/openagents.com/issues"}
                variant={:secondary}
                size={:lg}
              >
                View issues
              </.button>
            <% else %>
              <.github_login id="home-cta-signin" size={:lg} />
              <%!-- Quieter than the action beside it. `variant` defaults to
              `:primary`, so two filled buttons sat side by side stating that
              both were the thing to do, which leaves a reader picking rather
              than proceeding. --%>
              <.button navigate={~p"/docs"} variant={:secondary} size={:lg}>
                Read the docs
              </.button>
            <% end %>
            <.github_login id="home-cta-signin" size={:lg} />
            <%!-- Quieter than the action beside it. `variant` defaults to
            `:primary`, so two filled buttons sat side by side stating that
            both were the thing to do, which leaves a reader picking rather
            than proceeding. --%>
            <.button navigate={~p"/docs"} variant={:secondary} size={:lg}>
              Read the docs
            </.button>
          </:actions>

          <%!-- Commented out rather than deleted: the frame is right, what goes

       |> put_flash(:error, "You cannot open an issue on that repository.")
       |> redirect(to: ~p"/")}
    else
      changeset = Issues.change_issue(%Issue{}, %{"title" => "", "body" => ""})
      changeset =
        Issues.change_issue(repository, %Issue{}, %{"title" => "", "body" => ""})

      can_write = Repositories.writable?(repository, user)

      {:ok,

    visible? = not is_nil(visible_repository)
    can_write = visible? and Repositories.writable?(repository, user)
    can_participate = visible? and Repositories.issue_participant?(repository, user)
    issue = Issues.get_issue!(socket.assigns.issue.id)
    issue = Issues.get_issue!(socket.assigns.repository, socket.assigns.issue.id)
    can_edit = can_write || (can_participate and author?(issue, user))

    socket

     |> assign(:repo, repo)
     |> assign(:repository, repository)
     |> assign(:projects, Projects.list_projects(repository))
     |> assign(:form, to_form(Projects.change_project(%Project{})))}
     |> assign(:form, to_form(Projects.change_project(repository, %Project{}, %{})))}
  end

  def handle_event("save", %{"project" => project_params}, socket) do

        {:noreply,
         socket
         |> assign(:projects, Projects.list_projects(socket.assigns.repository))
         |> assign(:form, to_form(Projects.change_project(%Project{})))
         |> assign(
           :form,
           to_form(Projects.change_project(socket.assigns.repository, %Project{}, %{}))
         )
         |> put_flash(:info, "Project created")}

      {:error, changeset} ->

    "/api/computer-agent-jobs/"
  ]

  @optional_forge_read_paths [
    "/api/v3/repos/:owner/:repo/issues",
    "/api/v3/repos/:owner/:repo/issues/:issue_number",
    "/api/v3/repos/:owner/:repo/projectsV2",
    "/api/v3/repos/:owner/:repo/projectsV2/:project_number",
    "/api/v3/repos/:owner/:repo/projectsV2/:project_number/items",
    "/api/v3/repos/:owner/:repo/projectsV2/:project_number/fields"
  ]

  @spec classes() :: [atom()]
  def classes, do: @classes


        false
      )

  defp policy(%{path: path, verb: verb})
       when path in @optional_forge_read_paths and verb in [:get, :head],
       do:
         declaration(
           :public_read,
           "anonymous or first-party bearer token",
           "forge:repository:read",
           false
         )

  defp policy(%{path: "/api/v3/" <> _path, verb: verb}) when verb in [:get, :head],
    do: declaration(:public_read, "anonymous", "published:forge", false)


    post "/device/authorizations", DeviceAuthorizationController, :create
    post "/device/authorizations/token", DeviceAuthorizationController, :token

    get "/repos/:owner/:repo/issues", IssueController, :index
    get "/repos/:owner/:repo/issues/:issue_number", IssueController, :show
    get "/repos/:owner/:repo/issues/:issue_number/comments", CommentController, :index
    get "/repos/:owner/:repo/issues/comments/:id", CommentController, :show
    get "/repos/:owner/:repo/issues/:issue_number/labels", IssueLabelController, :index

    get "/repos/:owner/:repo/milestones/:milestone_number", MilestoneController, :show
    get "/repos/:owner/:repo/assignees", AssigneeController, :index
    get "/repos/:owner/:repo/assignees/:assignee", AssigneeController, :show
    get "/users/:username/projectsV2", ProjectController, :index
    get "/users/:username/projectsV2/:project_number", ProjectController, :show
    get "/users/:username/projectsV2/:project_number/items", ProjectController, :items
    get "/users/:username/projectsV2/:project_number/fields", ProjectController, :fields
  end

  scope "/api/v3", OpenAgentsWeb do
    pipe_through :optional_forge_api

    get "/repos/:owner/:repo", RepositoryController, :show
    get "/repos/:owner/:repo/issues", IssueController, :index
    get "/repos/:owner/:repo/issues/:issue_number", IssueController, :show
    get "/repos/:owner/:repo/projectsV2", ProjectController, :index
    get "/repos/:owner/:repo/projectsV2/:project_number", ProjectController, :show
    get "/repos/:owner/:repo/projectsV2/:project_number/items", ProjectController, :items
    get "/repos/:owner/:repo/projectsV2/:project_number/fields", ProjectController, :fields
  end

  scope "/api/v3", OpenAgentsWeb do

    put "/repos/:owner/:repo/milestones/:milestone_number", MilestoneController, :update
    patch "/repos/:owner/:repo/milestones/:milestone_number", MilestoneController, :update
    delete "/repos/:owner/:repo/milestones/:milestone_number", MilestoneController, :delete
    post "/:owner/projectsV2", ProjectController, :create
    post "/users/:username/projectsV2/:project_number/items", ProjectController, :create_item
    post "/users/:username/projectsV2/:project_number/fields", ProjectController, :create_field
    post "/repos/:owner/:repo/projectsV2", ProjectController, :create

    post "/repos/:owner/:repo/projectsV2/:project_number/items",
         ProjectController,
         :create_item

    post "/repos/:owner/:repo/projectsV2/:project_number/fields",
         ProjectController,
         :create_field

    patch "/users/:username/projectsV2/:project_number/items/:item_id",
    patch "/repos/:owner/:repo/projectsV2/:project_number/items/:item_id",
          ProjectController,
          :update_item
  end


## Through the API

Projects are exposed under `/users/:username/projectsV2`, shaped after GitHub's
ProjectsV2. See [REST API](/docs/rest-api).

## A current limitation

The project endpoints do not scope by the `:username` in the path, so a project
is reachable under any username. Treat project URLs as unguessable rather than
access-controlled until that is closed.
Projects are exposed under `/repos/:owner/:repo/projectsV2`. The repository in
the path controls visibility and write authority for every project, item, and
field operation. See [REST API](/docs/rest-api).

## Projects

```
GET    /api/v3/users/:username/projectsV2
GET    /api/v3/users/:username/projectsV2/:project_number
GET    /api/v3/users/:username/projectsV2/:project_number/items
GET    /api/v3/users/:username/projectsV2/:project_number/fields
GET    /api/v3/repos/:owner/:repo/projectsV2
POST   /api/v3/repos/:owner/:repo/projectsV2
GET    /api/v3/repos/:owner/:repo/projectsV2/:project_number
GET    /api/v3/repos/:owner/:repo/projectsV2/:project_number/items
POST   /api/v3/repos/:owner/:repo/projectsV2/:project_number/items
PATCH  /api/v3/repos/:owner/:repo/projectsV2/:project_number/items/:item_id
GET    /api/v3/repos/:owner/:repo/projectsV2/:project_number/fields
POST   /api/v3/repos/:owner/:repo/projectsV2/:project_number/fields
```

## Known differences from GitHub

- Renaming a label via `new_name` is accepted and ignored; the path name wins.
- Applying a label that does not exist returns 404. GitHub creates it.
- Removing a label an issue does not carry succeeds silently. GitHub returns 404.
- The assignable-users endpoint always returns an empty list.
- Project endpoints ignore the `:username` in the path.
- A non-numeric issue, milestone, or project number is a 500 rather than a 404.

## What is not implemented

  alias OpenAgents.Repositories

  setup do
    repository = Repositories.initial_repository!()
    repository = Repositories.get_by_path!("OpenAgentsInc", "openagents.com")

    {:ok, open} =
      Issues.create_issue(repository, %{"title" => "First open", "body" => "alpha body"})

  alias OpenAgents.Issues.Comment
  alias OpenAgents.Issues.Issue

  import OpenAgents.IssuesFixtures
  import OpenAgents.LabelsFixtures
  import OpenAgents.MilestonesFixtures
  import OpenAgents.AccountsFixtures

  setup do
    Enum.each(~w(alice bob carol), &repository_user_fixture/1)
    repository = repository_fixture()

    Enum.each(~w(alice bob carol), fn login ->
      user = repository_user_fixture(login)
      {:ok, _membership} = OpenAgents.Repositories.add_member(repository, user, "contributor")
    end)

    Process.put({__MODULE__, :repository}, repository)
    on_exit(fn -> Process.delete({__MODULE__, :repository}) end)
    :ok
  end


    {1, nil} =
      Repo.update_all(from(i in Issue, where: i.id == ^issue.id), set: [inserted_at: at])

    Issues.get_issue!(issue.id)
    Issues.get_issue!(repository(), issue.id)
  end

  describe "list_issues/1" do

      closed = issue_fixture(title: "closed one")
      {:ok, closed} = Issues.update_issue(closed, %{"state" => "closed"})

      numbers = Issues.list_issues() |> Enum.map(& &1.number)
      numbers = Issues.list_issues(repository()) |> Enum.map(& &1.number)

      assert open.number in numbers
      refute closed.number in numbers

      closed = issue_fixture(title: "closed one")
      {:ok, closed} = Issues.update_issue(closed, %{"state" => "closed"})

      assert Issues.list_issues(state: "closed") |> Enum.map(& &1.number) == [closed.number]
      assert Issues.list_issues(repository(), state: "closed") |> Enum.map(& &1.number) == [
               closed.number
             ]
    end

    test "state: \"all\" skips the filter" do

      closed = issue_fixture(title: "closed one")
      {:ok, _} = Issues.update_issue(closed, %{"state" => "closed"})

      numbers = Issues.list_issues(state: "all") |> Enum.map(& &1.number) |> Enum.sort()
      numbers =
        Issues.list_issues(repository(), state: "all") |> Enum.map(& &1.number) |> Enum.sort()

      assert numbers == Enum.sort([open.number, closed.number])
    end

    test "returns an empty list when nothing matches" do
      assert Issues.list_issues() == []
      assert Issues.list_issues(state: "all") == []
      assert Issues.list_issues(repository()) == []
      assert Issues.list_issues(repository(), state: "all") == []
    end

    test "orders newest first" do

      middle = issue_fixture(title: "middle") |> backdate!(200)
      newest = issue_fixture(title: "newest") |> backdate!(100)

      assert Issues.list_issues() |> Enum.map(& &1.id) == [newest.id, middle.id, oldest.id]
      assert Issues.list_issues(repository()) |> Enum.map(& &1.id) == [
               newest.id,
               middle.id,
               oldest.id
             ]
    end
  end

  describe "get_issue!/1 and get_issue_by_number!/1" do
    test "get_issue!/1 returns the issue with the given id" do
      issue = issue_fixture()
      assert Issues.get_issue!(issue.id) == issue
      assert Issues.get_issue!(repository(), issue.id) == issue
    end

    test "get_issue!/1 raises for an unknown id" do
      issue = issue_fixture()
      assert_raise Ecto.NoResultsError, fn -> Issues.get_issue!(issue.id + 1) end
      assert_raise Ecto.NoResultsError, fn -> Issues.get_issue!(repository(), issue.id + 1) end
    end

    test "get_issue_by_number!/1 returns the issue with the given number" do
      issue = issue_fixture()
      assert Issues.get_issue_by_number!(issue.number) == issue
      assert Issues.get_issue_by_number!(repository(), issue.number) == issue
    end

    test "get_issue_by_number!/1 raises for an unknown number" do
      issue = issue_fixture()
      assert_raise Ecto.NoResultsError, fn -> Issues.get_issue_by_number!(issue.number + 1) end

      assert_raise Ecto.NoResultsError, fn ->
        Issues.get_issue_by_number!(repository(), issue.number + 1)
      end
    end
  end

  describe "create_issue/1" do
    test "assigns numbers from one upwards" do
      assert {:ok, %Issue{number: 1}} = Issues.create_issue(%{title: "one"})
      assert {:ok, %Issue{number: 2}} = Issues.create_issue(%{title: "two"})
      assert {:ok, %Issue{number: 3}} = Issues.create_issue(%{title: "three"})
      assert {:ok, %Issue{number: 1}} = Issues.create_issue(repository(), %{title: "one"})
      assert {:ok, %Issue{number: 2}} = Issues.create_issue(repository(), %{title: "two"})
      assert {:ok, %Issue{number: 3}} = Issues.create_issue(repository(), %{title: "three"})
    end

    test "ignores a caller-supplied number" do
      assert {:ok, %Issue{number: 1}} = Issues.create_issue(%{title: "one", number: 99})
      assert {:ok, %Issue{number: 1}} =
               Issues.create_issue(repository(), %{title: "one", number: 99})
    end

    test "sets the documented defaults" do
      assert {:ok, %Issue{} = issue} = Issues.create_issue(%{title: "defaults"})
      assert {:ok, %Issue{} = issue} = Issues.create_issue(repository(), %{title: "defaults"})

      assert issue.state == "open"
      assert issue.locked == false


    test "accepts string keys" do
      assert {:ok, %Issue{} = issue} =
               Issues.create_issue(%{"title" => "strings", "body" => "hello"})
               Issues.create_issue(repository(), %{"title" => "strings", "body" => "hello"})

      assert issue.title == "strings"
      assert issue.body == "hello"
    end

    test "requires a title" do
      assert {:error, %Ecto.Changeset{} = changeset} = Issues.create_issue(%{body: "no title"})
      assert {:error, %Ecto.Changeset{} = changeset} =
               Issues.create_issue(repository(), %{body: "no title"})

      assert %{title: ["can't be blank"]} = errors_on(changeset)
    end

    test "called with no attrs at all it still refuses" do
      assert {:error, %Ecto.Changeset{} = changeset} = Issues.create_issue()
      assert {:error, %Ecto.Changeset{} = changeset} = Issues.create_issue(repository(), %{})
      assert %{title: ["can't be blank"]} = errors_on(changeset)
    end


      label = label_fixture(name: "bug", color: "d73a4a", description: "Something broken")

      assert {:ok, %Issue{} = issue} =
               Issues.create_issue(%{title: "labelled", labels: ["bug"]})
               Issues.create_issue(repository(), %{title: "labelled", labels: ["bug"]})

      assert issue.labels == [
               %{


    test "rejects a label outside the repository label set" do
      assert_raise Ecto.NoResultsError, fn ->
        Issues.create_issue(%{title: "labelled", labels: ["nope"]})
        Issues.create_issue(repository(), %{title: "labelled", labels: ["nope"]})
      end
    end


      label = label_fixture(name: "bug", color: "abcdef")
      given = [%{"name" => "bug", "color" => "abcdef"}]

      assert {:ok, %Issue{} = issue} = Issues.create_issue(%{title: "labelled", labels: given})
      assert {:ok, %Issue{} = issue} =
               Issues.create_issue(repository(), %{title: "labelled", labels: given})

      assert issue.labels == [
               %{

    end

    test "accepts an empty label list" do
      assert {:ok, %Issue{labels: []}} = Issues.create_issue(%{title: "none", labels: []})
      assert {:ok, %Issue{labels: []}} =
               Issues.create_issue(repository(), %{title: "none", labels: []})
    end

    test "expands assignee logins into assignee maps" do
      assert {:ok, %Issue{} = issue} =
               Issues.create_issue(%{title: "assigned", assignees: ["alice", "bob"]})
               Issues.create_issue(repository(), %{title: "assigned", assignees: ["alice", "bob"]})

      assert issue.assignees == [%{"login" => "alice"}, %{"login" => "bob"}]
    end

    test "canonicalizes assignee maps from repository membership" do
      given = [%{"login" => "alice", "id" => 7}]

      assert {:ok, %Issue{} = issue} = Issues.create_issue(%{title: "assigned", assignees: given})
      assert {:ok, %Issue{} = issue} =
               Issues.create_issue(repository(), %{title: "assigned", assignees: given})

      assert issue.assignees == [%{"login" => "alice"}]
    end


      milestone = milestone_fixture(title: "v1", state: "open", due_on: "2026-01-01")

      assert {:ok, %Issue{} = issue} =
               Issues.create_issue(%{title: "planned", milestone: milestone.number})
               Issues.create_issue(repository(), %{title: "planned", milestone: milestone.number})

      assert issue.milestone == %{
               "number" => milestone.number,


    test "raises for an unknown milestone number" do
      assert_raise Ecto.NoResultsError, fn ->
        Issues.create_issue(%{title: "planned", milestone: 404})
        Issues.create_issue(repository(), %{title: "planned", milestone: 404})
      end
    end

    test "accepts an explicit nil milestone" do
      assert {:ok, %Issue{milestone: nil}} =
               Issues.create_issue(%{title: "unplanned", milestone: nil})
               Issues.create_issue(repository(), %{title: "unplanned", milestone: nil})
    end
  end


      issue = issue_fixture()

      assert {:error, %Ecto.Changeset{}} = Issues.update_issue(issue, %{"title" => nil})
      assert issue == Issues.get_issue!(issue.id)
      assert issue == Issues.get_issue!(repository(), issue.id)
    end

    test "closing stamps closed_at and defaults the state reason" do


      assert %{color: color} =
               OpenAgents.Labels.get_label_by_name!(
                 OpenAgents.Repositories.initial_repository!(),
                 repository(),
                 "nope"
               )


      refute is_nil(comment.created_at)
      refute is_nil(comment.updated_at)

      assert Issues.get_issue!(issue.id).comments == 1
      assert Issues.get_issue!(repository(), issue.id).comments == 1
    end

    test "create_comment/1 keeps explicit timestamps" do

               Issues.create_comment(%{body: nil, issue_id: issue.id})

      assert %{body: ["can't be blank"]} = errors_on(changeset)
      assert Issues.get_issue!(issue.id).comments == 0
      assert Issues.get_issue!(repository(), issue.id).comments == 0
    end

    test "create_comment/1 requires an issue_id" do

    end

    test "create_comment/0 refuses an empty comment" do
      assert {:error, %Ecto.Changeset{} = changeset} = Issues.create_comment()
      assert {:error, %Ecto.Changeset{} = changeset} = Issues.create_comment(%{})
      assert %{body: ["can't be blank"], issue_id: ["can't be blank"]} = errors_on(changeset)
    end


      issue = issue_fixture()
      {:ok, comment} = Issues.create_comment(%{body: "hello", issue_id: issue.id})

      assert Issues.get_comment!(comment.id) == comment
      assert Issues.get_comment!(repository(), comment.id) == comment
    end

    test "get_comment!/1 raises for an unknown id" do
      issue = issue_fixture()
      {:ok, comment} = Issues.create_comment(%{body: "hello", issue_id: issue.id})

      assert_raise Ecto.NoResultsError, fn -> Issues.get_comment!(comment.id + 1) end
      assert_raise Ecto.NoResultsError, fn ->
        Issues.get_comment!(repository(), comment.id + 1)
      end
    end

    test "list_comments/1 is scoped to one issue and ordered by creation time" do


      {:ok, _elsewhere} = Issues.create_comment(%{body: "elsewhere", issue_id: other.id})

      assert Issues.list_comments(issue.id) |> Enum.map(& &1.id) == [first.id, second.id]
      assert Issues.list_comments(issue) |> Enum.map(& &1.id) == [first.id, second.id]
    end

    test "list_comments/1 returns an empty list for an issue with no comments" do
      issue = issue_fixture()
      assert Issues.list_comments(issue.id) == []
      assert Issues.list_comments(issue) == []
    end

    test "update_comment/2 edits the body and bumps updated_at" do

      {:ok, comment} = Issues.create_comment(%{body: "before", issue_id: issue.id})

      assert {:error, %Ecto.Changeset{}} = Issues.update_comment(comment, %{body: nil})
      assert Issues.get_comment!(comment.id).body == "before"
      assert Issues.get_comment!(repository(), comment.id).body == "before"
    end

    test "delete_comment/1 removes it and decrements the issue counter" do
      issue = issue_fixture()
      {:ok, comment} = Issues.create_comment(%{body: "hello", issue_id: issue.id})
      assert Issues.get_issue!(issue.id).comments == 1
      assert Issues.get_issue!(repository(), issue.id).comments == 1

      assert {:ok, :ok} = Issues.delete_comment(comment)

      assert_raise Ecto.NoResultsError, fn -> Issues.get_comment!(comment.id) end
      assert Issues.get_issue!(issue.id).comments == 0
      assert_raise Ecto.NoResultsError, fn -> Issues.get_comment!(repository(), comment.id) end
      assert Issues.get_issue!(repository(), issue.id).comments == 0
    end

    test "the counter tracks several comments" do
      issue = issue_fixture()
      {:ok, a} = Issues.create_comment(%{body: "a", issue_id: issue.id})
      {:ok, _b} = Issues.create_comment(%{body: "b", issue_id: issue.id})
      assert Issues.get_issue!(issue.id).comments == 2
      assert Issues.get_issue!(repository(), issue.id).comments == 2

      {:ok, :ok} = Issues.delete_comment(a)
      assert Issues.get_issue!(issue.id).comments == 1
      assert Issues.get_issue!(repository(), issue.id).comments == 1
    end
  end

  defp repository, do: Process.get({__MODULE__, :repository})

  defp issue_fixture(attrs \\ %{}) do
    OpenAgents.IssuesFixtures.issue_fixture(repository(), attrs)
  end

  defp label_fixture(attrs) do
    OpenAgents.LabelsFixtures.label_fixture(repository(), attrs)
  end

  defp milestone_fixture(attrs) do
    OpenAgents.MilestonesFixtures.milestone_fixture(repository(), attrs)
  end
end


  alias OpenAgents.Labels

  setup do
    Process.put({__MODULE__, :repository}, repository_fixture())
    on_exit(fn -> Process.delete({__MODULE__, :repository}) end)
    :ok
  end

  describe "labels" do
    alias OpenAgents.Labels.Label


    @invalid_attrs %{name: nil, description: nil, color: nil}

    test "list_labels/0 returns all labels" do
      label = label_fixture()
      assert Labels.list_labels() == [label]
      label = label_fixture(repository())
      assert Labels.list_labels(repository()) == [label]
    end

    test "get_label!/1 returns the label with given id" do
      label = label_fixture()
      assert Labels.get_label!(label.id) == label
      label = label_fixture(repository())
      assert Labels.get_label!(repository(), label.id) == label
    end

    test "create_label/1 with valid data creates a label" do
      valid_attrs = %{name: "some name", description: "some description", color: "some color"}

      assert {:ok, %Label{} = label} = Labels.create_label(valid_attrs)
      assert {:ok, %Label{} = label} = Labels.create_label(repository(), valid_attrs)
      assert label.name == "some name"
      assert label.description == "some description"
      assert label.color == "some color"
    end

    test "create_label/1 with invalid data returns error changeset" do
      assert {:error, %Ecto.Changeset{}} = Labels.create_label(@invalid_attrs)
      assert {:error, %Ecto.Changeset{}} = Labels.create_label(repository(), @invalid_attrs)
    end

    test "update_label/2 with valid data updates the label" do
      label = label_fixture()
      label = label_fixture(repository())

      update_attrs = %{
        name: "some updated name",

    end

    test "update_label/2 with invalid data returns error changeset" do
      label = label_fixture()
      label = label_fixture(repository())
      assert {:error, %Ecto.Changeset{}} = Labels.update_label(label, @invalid_attrs)
      assert label == Labels.get_label!(label.id)
      assert label == Labels.get_label!(repository(), label.id)
    end

    test "delete_label/1 deletes the label" do
      label = label_fixture()
      label = label_fixture(repository())
      assert {:ok, %Label{}} = Labels.delete_label(label)
      assert_raise Ecto.NoResultsError, fn -> Labels.get_label!(label.id) end
      assert_raise Ecto.NoResultsError, fn -> Labels.get_label!(repository(), label.id) end
    end

    test "change_label/1 returns a label changeset" do
      label = label_fixture()
      label = label_fixture(repository())
      assert %Ecto.Changeset{} = Labels.change_label(label)
    end

    test "change_label/2 applies attrs and surfaces validation errors" do
      label = label_fixture()
      label = label_fixture(repository())

      assert Labels.change_label(label, %{name: "renamed"}).valid?


    end

    test "get_label_by_name!/1 returns the label with the given name" do
      label = label_fixture(name: "bug")
      assert Labels.get_label_by_name!("bug") == label
      label = label_fixture(repository(), name: "bug")
      assert Labels.get_label_by_name!(repository(), "bug") == label
    end

    test "get_label_by_name!/1 decodes a percent-encoded name" do
      label = label_fixture(name: "help wanted")
      assert Labels.get_label_by_name!("help%20wanted") == label
      label = label_fixture(repository(), name: "help wanted")
      assert Labels.get_label_by_name!(repository(), "help%20wanted") == label
    end

    test "get_label_by_name!/1 raises for an unknown name" do
      label_fixture(name: "bug")
      assert_raise Ecto.NoResultsError, fn -> Labels.get_label_by_name!("nope") end
      label_fixture(repository(), name: "bug")

      assert_raise Ecto.NoResultsError, fn ->
        Labels.get_label_by_name!(repository(), "nope")
      end
    end
  end

  defp repository, do: Process.get({__MODULE__, :repository})
end


  alias OpenAgents.Milestones

  setup do
    Process.put({__MODULE__, :repository}, repository_fixture())
    on_exit(fn -> Process.delete({__MODULE__, :repository}) end)
    :ok
  end

  describe "milestones" do
    alias OpenAgents.Milestones.Milestone


    @invalid_attrs %{state: nil, description: nil, title: nil, number: nil, due_on: nil}

    test "list_milestones/0 returns all milestones" do
      milestone = milestone_fixture()
      assert Milestones.list_milestones() == [milestone]
      milestone = milestone_fixture(repository())
      assert Milestones.list_milestones(repository()) == [milestone]
    end

    test "get_milestone!/1 returns the milestone with given id" do
      milestone = milestone_fixture()
      assert Milestones.get_milestone!(milestone.id) == milestone
      milestone = milestone_fixture(repository())
      assert Milestones.get_milestone!(repository(), milestone.id) == milestone
    end

    test "create_milestone/1 with valid data creates a milestone" do

        due_on: "some due_on"
      }

      assert {:ok, %Milestone{} = milestone} = Milestones.create_milestone(valid_attrs)
      assert {:ok, %Milestone{} = milestone} =
               Milestones.create_milestone(repository(), valid_attrs)

      assert milestone.state == "some state"
      assert milestone.description == "some description"
      assert milestone.title == "some title"

    end

    test "create_milestone/1 with invalid data returns error changeset" do
      assert {:error, %Ecto.Changeset{}} = Milestones.create_milestone(@invalid_attrs)
      assert {:error, %Ecto.Changeset{}} =
               Milestones.create_milestone(repository(), @invalid_attrs)
    end

    test "update_milestone/2 updates mutable fields but preserves its repository number" do
      milestone = milestone_fixture()
      milestone = milestone_fixture(repository())

      update_attrs = %{
        state: "some updated state",

    end

    test "update_milestone/2 with invalid data returns error changeset" do
      milestone = milestone_fixture()
      milestone = milestone_fixture(repository())
      assert {:error, %Ecto.Changeset{}} = Milestones.update_milestone(milestone, @invalid_attrs)
      assert milestone == Milestones.get_milestone!(milestone.id)
      assert milestone == Milestones.get_milestone!(repository(), milestone.id)
    end

    test "delete_milestone/1 deletes the milestone" do
      milestone = milestone_fixture()
      milestone = milestone_fixture(repository())
      assert {:ok, %Milestone{}} = Milestones.delete_milestone(milestone)
      assert_raise Ecto.NoResultsError, fn -> Milestones.get_milestone!(milestone.id) end

      assert_raise Ecto.NoResultsError, fn ->
        Milestones.get_milestone!(repository(), milestone.id)
      end
    end

    test "change_milestone/1 returns a milestone changeset" do
      milestone = milestone_fixture()
      milestone = milestone_fixture(repository())
      assert %Ecto.Changeset{} = Milestones.change_milestone(milestone)
    end

    test "change_milestone/2 applies attrs and surfaces validation errors" do
      milestone = milestone_fixture()
      milestone = milestone_fixture(repository())

      assert Milestones.change_milestone(milestone, %{title: "renamed"}).valid?



    test "create_milestone/1 assigns numbers from one upwards" do
      assert {:ok, %Milestone{number: 1}} =
               Milestones.create_milestone(%{title: "v1", state: "open"})
               Milestones.create_milestone(repository(), %{title: "v1", state: "open"})

      assert {:ok, %Milestone{number: 2}} =
               Milestones.create_milestone(%{title: "v2", state: "open"})
               Milestones.create_milestone(repository(), %{title: "v2", state: "open"})
    end

    test "create_milestone/1 honours an explicit number and continues from it" do
      assert {:ok, %Milestone{number: 10}} =
               Milestones.create_milestone(%{title: "v10", state: "open", number: 10})
               Milestones.create_milestone(repository(), %{
                 title: "v10",
                 state: "open",
                 number: 10
               })

      assert {:ok, %Milestone{number: 11}} =
               Milestones.create_milestone(%{title: "v11", state: "open"})
               Milestones.create_milestone(repository(), %{title: "v11", state: "open"})
    end

    test "create_milestone/0 refuses an empty milestone" do
      assert {:error, %Ecto.Changeset{} = changeset} = Milestones.create_milestone()
      assert {:error, %Ecto.Changeset{} = changeset} =
               Milestones.create_milestone(repository(), %{})

      assert %{title: ["can't be blank"]} = errors_on(changeset)
    end

    test "create_milestone/1 accepts string keys" do
      assert {:ok, %Milestone{} = milestone} =
               Milestones.create_milestone(%{"title" => "v1", "state" => "open"})
               Milestones.create_milestone(repository(), %{"title" => "v1", "state" => "open"})

      assert milestone.title == "v1"
      assert milestone.state == "open"
    end

    test "get_milestone_by_number!/1 returns the milestone with the given number" do
      milestone = milestone_fixture(number: 7)
      assert Milestones.get_milestone_by_number!(7) == milestone
      milestone = milestone_fixture(repository(), number: 7)
      assert Milestones.get_milestone_by_number!(repository(), 7) == milestone
    end

    test "get_milestone_by_number!/1 raises for an unknown number" do
      milestone_fixture(number: 7)
      assert_raise Ecto.NoResultsError, fn -> Milestones.get_milestone_by_number!(8) end
      milestone_fixture(repository(), number: 7)

      assert_raise Ecto.NoResultsError, fn ->
        Milestones.get_milestone_by_number!(repository(), 8)
      end
    end
  end

  defp repository, do: Process.get({__MODULE__, :repository})
end


  alias OpenAgents.ProjectFields

  setup do
    Process.put({__MODULE__, :repository}, repository_fixture())
    on_exit(fn -> Process.delete({__MODULE__, :repository}) end)
    :ok
  end

  describe "project_fields" do
    alias OpenAgents.ProjectFields.ProjectField


    @invalid_attrs %{name: nil, data_type: nil, options: nil, project_id: nil}

    test "list_project_fields/0 returns all project_fields" do
      project_field = project_field_fixture()
      project_field = project_field_fixture(repository())
      assert ProjectFields.list_project_fields() == [project_field]
    end


    end

    test "list_project_fields/0 spans projects" do
      a = project_field_fixture(name: "Status")
      b = project_field_fixture(name: "Priority")
      a = project_field_fixture(repository(), name: "Status")
      b = project_field_fixture(repository(), name: "Priority")

      ids = ProjectFields.list_project_fields() |> Enum.map(& &1.id) |> Enum.sort()
      assert ids == Enum.sort([a.id, b.id])
    end

    test "get_project_field!/1 returns the project_field with given id" do
      project_field = project_field_fixture()
      project_field = project_field_fixture(repository())
      assert ProjectFields.get_project_field!(project_field.id) == project_field
    end

    test "get_project_field!/1 raises for an unknown id" do
      project_field = project_field_fixture()
      project_field = project_field_fixture(repository())

      assert_raise Ecto.NoResultsError, fn ->
        ProjectFields.get_project_field!(project_field.id + 1)

    end

    test "create_project_field/1 with valid data creates a project_field" do
      project = project_fixture()
      project = project_fixture(repository())

      valid_attrs = %{
        name: "Status",

    end

    test "create_project_field/1 leaves options nil when omitted" do
      project = project_fixture()
      project = project_fixture(repository())

      assert {:ok, %ProjectField{} = project_field} =
               ProjectFields.create_project_field(%{

    end

    test "update_project_field/2 with valid data updates the project_field" do
      project_field = project_field_fixture()
      project_field = project_field_fixture(repository())

      update_attrs = %{
        name: "some updated name",

    end

    test "update_project_field/2 can move a field to another project" do
      project_field = project_field_fixture()
      other = project_fixture(number: 99)
      project_field = project_field_fixture(repository())
      other = project_fixture(repository(), number: 99)

      assert {:ok, %ProjectField{} = moved} =
               ProjectFields.update_project_field(project_field, %{project_id: other.id})

    end

    test "update_project_field/2 with invalid data returns error changeset" do
      project_field = project_field_fixture()
      project_field = project_field_fixture(repository())

      assert {:error, %Ecto.Changeset{}} =
               ProjectFields.update_project_field(project_field, @invalid_attrs)

    end

    test "delete_project_field/1 deletes the project_field" do
      project_field = project_field_fixture()
      project_field = project_field_fixture(repository())
      assert {:ok, %ProjectField{}} = ProjectFields.delete_project_field(project_field)

      assert_raise Ecto.NoResultsError, fn ->

    end

    test "change_project_field/1 returns a project_field changeset" do
      project_field = project_field_fixture()
      project_field = project_field_fixture(repository())
      assert %Ecto.Changeset{} = ProjectFields.change_project_field(project_field)
    end

    test "change_project_field/2 applies the given attrs" do
      project_field = project_field_fixture()
      project_field = project_field_fixture(repository())

      changeset = ProjectFields.change_project_field(project_field, %{name: "Renamed"})


    end

    test "change_project_field/2 surfaces validation errors without touching the database" do
      project_field = project_field_fixture()
      project_field = project_field_fixture(repository())

      changeset = ProjectFields.change_project_field(project_field, %{name: nil})


174	180		`assert project_field == ProjectFields.get_project_field!(project_field.id)`
175	181		`end`
176	182		`end`
	183	+
	184	+	`defp repository, do: Process.get({__MODULE__, :repository})`
177	185		`end`


  alias OpenAgents.ProjectItems

  setup do
    Process.put({__MODULE__, :repository}, repository_fixture())
    on_exit(fn -> Process.delete({__MODULE__, :repository}) end)
    :ok
  end

  describe "project_items" do
    alias OpenAgents.ProjectItems.ProjectItem


    @invalid_attrs %{values: nil, project_id: nil, issue_id: nil}

    test "list_project_items/0 returns all project_items" do
      project_item = project_item_fixture()
      assert ProjectItems.list_project_items() == [project_item]
      project_item = project_item_fixture(repository())
      assert ProjectItems.list_project_items(repository()) == [project_item]
    end

    test "list_project_items/0 returns an empty list when none exist" do
      assert ProjectItems.list_project_items() == []
      assert ProjectItems.list_project_items(repository()) == []
    end

    test "list_project_items/0 is not scoped to a project" do
      a = project_item_fixture()
      b = project_item_fixture()
      a = project_item_fixture(repository())
      b = project_item_fixture(repository())

      refute a.project_id == b.project_id

      ids = ProjectItems.list_project_items() |> Enum.map(& &1.id) |> Enum.sort()
      ids = ProjectItems.list_project_items(repository()) |> Enum.map(& &1.id) |> Enum.sort()
      assert ids == Enum.sort([a.id, b.id])
    end

    test "get_project_item!/1 returns the project_item with given id" do
      project_item = project_item_fixture()
      assert ProjectItems.get_project_item!(project_item.id) == project_item
      project_item = project_item_fixture(repository())
      assert ProjectItems.get_project_item!(repository(), project_item.id) == project_item
    end

    test "get_project_item!/1 raises for an unknown id" do
      project_item = project_item_fixture()
      project_item = project_item_fixture(repository())

      assert_raise Ecto.NoResultsError, fn ->
        ProjectItems.get_project_item!(project_item.id + 1)
        ProjectItems.get_project_item!(repository(), project_item.id + 1)
      end
    end

    test "create_project_item/1 with valid data creates a project_item" do
      project = project_fixture()
      issue = issue_fixture()
      project = project_fixture(repository())
      issue = issue_fixture(repository())

      valid_attrs = %{
        values: %{"Status" => "In Progress"},

      }

      assert {:ok, %ProjectItem{} = project_item} =
               ProjectItems.create_project_item(valid_attrs)
               ProjectItems.create_project_item(repository(), valid_attrs)

      assert project_item.values == %{"Status" => "In Progress"}
      assert project_item.project_id == project.id

    end

    test "create_project_item/1 leaves values nil when omitted" do
      project = project_fixture()
      issue = issue_fixture()
      project = project_fixture(repository())
      issue = issue_fixture(repository())

      assert {:ok, %ProjectItem{} = project_item} =
               ProjectItems.create_project_item(%{project_id: project.id, issue_id: issue.id})
               ProjectItems.create_project_item(repository(), %{
                 project_id: project.id,
                 issue_id: issue.id
               })

      assert is_nil(project_item.values)
    end

    test "create_project_item/1 with invalid data returns error changeset" do
      assert {:error, %Ecto.Changeset{} = changeset} =
               ProjectItems.create_project_item(@invalid_attrs)
               ProjectItems.create_project_item(repository(), @invalid_attrs)

      assert %{project_id: ["can't be blank"], issue_id: ["can't be blank"]} =
               errors_on(changeset)
    end

    test "create_project_item/1 does not require values" do
      assert {:error, changeset} = ProjectItems.create_project_item(%{values: %{}})
      assert {:error, changeset} = ProjectItems.create_project_item(repository(), %{values: %{}})

      refute Map.has_key?(errors_on(changeset), :values)


    end

    test "create_project_item/1 requires an issue_id even with a project" do
      project = project_fixture()
      project = project_fixture(repository())

      assert {:error, changeset} =
               ProjectItems.create_project_item(repository(), %{project_id: project.id})

      assert {:error, changeset} = ProjectItems.create_project_item(%{project_id: project.id})
      assert %{issue_id: ["can't be blank"]} = errors_on(changeset)
      refute Map.has_key?(errors_on(changeset), :project_id)
    end

    test "create_project_item/1 reports a dangling project as a changeset error" do
      issue = issue_fixture()
      issue = issue_fixture(repository())

      assert {:error, changeset} =
               ProjectItems.create_project_item(%{
               ProjectItems.create_project_item(repository(), %{
                 project_id: 2_147_483_000,
                 issue_id: issue.id
               })

    end

    test "create_project_item/1 allows the same issue in two projects" do
      issue = issue_fixture()
      one = project_fixture(number: 1)
      two = project_fixture(number: 2)
      issue = issue_fixture(repository())
      one = project_fixture(repository(), number: 1)
      two = project_fixture(repository(), number: 2)

      assert {:ok, %ProjectItem{}} =
               ProjectItems.create_project_item(%{project_id: one.id, issue_id: issue.id})
               ProjectItems.create_project_item(repository(), %{
                 project_id: one.id,
                 issue_id: issue.id
               })

      assert {:ok, %ProjectItem{}} =
               ProjectItems.create_project_item(%{project_id: two.id, issue_id: issue.id})
               ProjectItems.create_project_item(repository(), %{
                 project_id: two.id,
                 issue_id: issue.id
               })

      assert length(ProjectItems.list_project_items()) == 2
      assert length(ProjectItems.list_project_items(repository())) == 2
    end

    test "update_project_item/2 with valid data updates the project_item" do
      project_item = project_item_fixture()
      project_item = project_item_fixture(repository())
      update_attrs = %{values: %{"Status" => "Done"}}

      assert {:ok, %ProjectItem{} = project_item} =

    end

    test "update_project_item/2 replaces values wholesale rather than merging" do
      project_item = project_item_fixture(values: %{"Status" => "Todo", "Size" => "L"})
      project_item =
        project_item_fixture(repository(), values: %{"Status" => "Todo", "Size" => "L"})

      assert {:ok, %ProjectItem{} = updated} =
               ProjectItems.update_project_item(project_item, %{values: %{"Status" => "Done"}})

    end

    test "update_project_item/2 with invalid data returns error changeset" do
      project_item = project_item_fixture()
      project_item = project_item_fixture(repository())

      assert {:error, %Ecto.Changeset{}} =
               ProjectItems.update_project_item(project_item, @invalid_attrs)

      assert project_item == ProjectItems.get_project_item!(project_item.id)
      assert project_item == ProjectItems.get_project_item!(repository(), project_item.id)
    end

    test "delete_project_item/1 deletes the project_item" do
      project_item = project_item_fixture()
      project_item = project_item_fixture(repository())
      assert {:ok, %ProjectItem{}} = ProjectItems.delete_project_item(project_item)

      assert_raise Ecto.NoResultsError, fn ->
        ProjectItems.get_project_item!(project_item.id)
        ProjectItems.get_project_item!(repository(), project_item.id)
      end
    end

    test "change_project_item/1 returns a project_item changeset" do
      project_item = project_item_fixture()
      project_item = project_item_fixture(repository())
      assert %Ecto.Changeset{} = ProjectItems.change_project_item(project_item)
    end

    test "change_project_item/2 applies the given attrs" do
      project_item = project_item_fixture()
      project_item = project_item_fixture(repository())

      changeset = ProjectItems.change_project_item(project_item, %{values: %{"Status" => "Done"}})


    end

    test "change_project_item/2 surfaces validation errors without touching the database" do
      project_item = project_item_fixture()
      project_item = project_item_fixture(repository())

      changeset = ProjectItems.change_project_item(project_item, %{issue_id: nil})

      refute changeset.valid?
      assert %{issue_id: ["can't be blank"]} = errors_on(changeset)
      assert project_item == ProjectItems.get_project_item!(project_item.id)
      assert project_item == ProjectItems.get_project_item!(repository(), project_item.id)
    end
  end

  defp repository, do: Process.get({__MODULE__, :repository})
end


  alias OpenAgents.Projects

  setup do
    Process.put({__MODULE__, :repository}, repository_fixture())
    on_exit(fn -> Process.delete({__MODULE__, :repository}) end)
    :ok
  end

  describe "projects" do
    alias OpenAgents.Projects.Project


    @invalid_attrs %{owner: nil, state: nil, title: nil, number: nil}

    test "list_projects/0 returns all projects" do
      project = project_fixture()
      assert Projects.list_projects() == [project]
      project = project_fixture(repository())
      assert Projects.list_projects(repository()) == [project]
    end

    test "get_project!/1 returns the project with given id" do
      project = project_fixture()
      assert Projects.get_project!(project.id) == project
      project = project_fixture(repository())
      assert Projects.get_project!(repository(), project.id) == project
    end

    test "create_project/1 with valid data creates a project" do
      valid_attrs = %{owner: "some owner", state: "some state", title: "some title", number: 42}

      assert {:ok, %Project{} = project} = Projects.create_project(valid_attrs)
      assert {:ok, %Project{} = project} = Projects.create_project(repository(), valid_attrs)
      assert project.owner == "some owner"
      assert project.state == "some state"
      assert project.title == "some title"

    end

    test "create_project/1 with invalid data returns error changeset" do
      assert {:error, %Ecto.Changeset{}} = Projects.create_project(@invalid_attrs)
      assert {:error, %Ecto.Changeset{}} = Projects.create_project(repository(), @invalid_attrs)
    end

    test "update_project/2 with valid data updates the project" do
      project = project_fixture()
      project = project_fixture(repository())

      update_attrs = %{
        owner: "some updated owner",

    end

    test "update_project/2 with invalid data returns error changeset" do
      project = project_fixture()
      project = project_fixture(repository())
      assert {:error, %Ecto.Changeset{}} = Projects.update_project(project, @invalid_attrs)
      assert project == Projects.get_project!(project.id)
      assert project == Projects.get_project!(repository(), project.id)
    end

    test "delete_project/1 deletes the project" do
      project = project_fixture()
      project = project_fixture(repository())
      assert {:ok, %Project{}} = Projects.delete_project(project)
      assert_raise Ecto.NoResultsError, fn -> Projects.get_project!(project.id) end
      assert_raise Ecto.NoResultsError, fn -> Projects.get_project!(repository(), project.id) end
    end

    test "change_project/1 returns a project changeset" do
      project = project_fixture()
      project = project_fixture(repository())
      assert %Ecto.Changeset{} = Projects.change_project(project)
    end

    test "change_project/2 applies the given attrs" do
      project = project_fixture()
      project = project_fixture(repository())

      changeset = Projects.change_project(project, %{title: "Renamed"})


    end

    test "change_project/2 surfaces validation errors" do
      project = project_fixture()
      project = project_fixture(repository())

      changeset = Projects.change_project(project, %{title: nil})



    test "create_project/1 defaults state to open" do
      assert {:ok, %Project{} = project} =
               Projects.create_project(%{title: "Roadmap", owner: "OpenAgents"})
               Projects.create_project(repository(), %{title: "Roadmap", owner: "OpenAgents"})

      assert project.state == "open"
    end

    test "create_project/1 assigns the next number when none is given" do
      assert {:ok, %Project{number: 1}} =
               Projects.create_project(%{title: "One", owner: "OpenAgents"})
               Projects.create_project(repository(), %{title: "One", owner: "OpenAgents"})

      assert {:ok, %Project{number: 2}} =
               Projects.create_project(%{title: "Two", owner: "OpenAgents"})
               Projects.create_project(repository(), %{title: "Two", owner: "OpenAgents"})

      assert {:ok, %Project{number: 3}} =
               Projects.create_project(%{title: "Three", owner: "OpenAgents"})
               Projects.create_project(repository(), %{title: "Three", owner: "OpenAgents"})
    end

    test "create_project/1 honours an explicit number and continues from it" do
      assert {:ok, %Project{number: 10}} =
               Projects.create_project(%{title: "Ten", owner: "OpenAgents", number: 10})
               Projects.create_project(repository(), %{
                 title: "Ten",
                 owner: "OpenAgents",
                 number: 10
               })

      assert {:ok, %Project{number: 11}} =
               Projects.create_project(%{title: "Next", owner: "OpenAgents"})
               Projects.create_project(repository(), %{title: "Next", owner: "OpenAgents"})
    end

    test "create_project/0 refuses an empty project" do
      assert {:error, %Ecto.Changeset{} = changeset} = Projects.create_project()
      assert {:error, %Ecto.Changeset{} = changeset} = Projects.create_project(repository(), %{})
      assert %{title: ["can't be blank"], owner: ["can't be blank"]} = errors_on(changeset)
    end

    test "create_project/1 accepts string keys" do
      assert {:ok, %Project{} = project} =
               Projects.create_project(%{"title" => "Strings", "owner" => "OpenAgents"})
               Projects.create_project(repository(), %{
                 "title" => "Strings",
                 "owner" => "OpenAgents"
               })

      assert project.title == "Strings"
      assert project.owner == "OpenAgents"

    end

    test "get_project_by_number!/1 returns the project with the given number" do
      project = project_fixture(number: 7)
      assert Projects.get_project_by_number!(7) == project
      project = project_fixture(repository(), number: 7)
      assert Projects.get_project_by_number!(repository(), 7) == project
    end

    test "get_project_by_number!/1 raises for an unknown number" do
      project_fixture(number: 7)
      assert_raise Ecto.NoResultsError, fn -> Projects.get_project_by_number!(8) end
      project_fixture(repository(), number: 7)
      assert_raise Ecto.NoResultsError, fn -> Projects.get_project_by_number!(repository(), 8) end
    end
  end


    import OpenAgents.ProjectsFixtures

    setup do
      project = project_fixture(number: 1)
      issue = issue_fixture(title: "First issue")
      project = project_fixture(repository(), number: 1)
      issue = issue_fixture(repository(), title: "First issue")
      %{project: project, issue: issue}
    end

    test "list_project_items/1 is scoped to one project", %{project: project, issue: issue} do
      other = project_fixture(number: 2)
      other = project_fixture(repository(), number: 2)

      {:ok, mine} =
        Projects.create_project_item(%{"issue_number" => issue.number}, project.id)
        Projects.create_project_item(%{"issue_number" => issue.number}, project)

      {:ok, _theirs} =
        Projects.create_project_item(%{"issue_number" => issue.number}, other.id)
        Projects.create_project_item(%{"issue_number" => issue.number}, other)

      assert Enum.map(Projects.list_project_items(project.id), & &1.id) == [mine.id]
      assert Enum.map(Projects.list_project_items(project), & &1.id) == [mine.id]
    end

    test "list_project_items/1 returns an empty list for a project with no items", %{
      project: project
    } do
      assert Projects.list_project_items(project.id) == []
      assert Projects.list_project_items(project) == []
    end

    test "get_project_item!/1 returns the item", %{project: project, issue: issue} do
      {:ok, item} = Projects.create_project_item(%{"issue_number" => issue.number}, project.id)
      assert Projects.get_project_item!(item.id) == item
      {:ok, item} = Projects.create_project_item(%{"issue_number" => issue.number}, project)
      assert Projects.get_project_item!(project, item.id) == item
    end

    test "get_project_item!/1 raises for an unknown id", %{project: project, issue: issue} do
      {:ok, item} = Projects.create_project_item(%{"issue_number" => issue.number}, project.id)
      assert_raise Ecto.NoResultsError, fn -> Projects.get_project_item!(item.id + 1) end
      {:ok, item} = Projects.create_project_item(%{"issue_number" => issue.number}, project)
      assert_raise Ecto.NoResultsError, fn -> Projects.get_project_item!(project, item.id + 1) end
    end

    test "create_project_item/2 resolves the issue by number", %{project: project, issue: issue} do
      assert {:ok, %ProjectItem{} = item} =
               Projects.create_project_item(
                 %{"issue_number" => issue.number, "values" => %{"Status" => "Todo"}},
                 project.id
                 project
               )

      assert item.project_id == project.id

      issue: issue
    } do
      assert {:ok, %ProjectItem{} = item} =
               Projects.create_project_item(%{"issue_number" => issue.number}, project.id)
               Projects.create_project_item(%{"issue_number" => issue.number}, project)

      assert item.values == %{}
    end

      assert {:ok, %ProjectItem{} = item} =
               Projects.create_project_item(
                 %{issue_number: issue.number, values: %{"Status" => "Todo"}},
                 project.id
                 project
               )

      assert item.issue_id == issue.id

                   "project_number" => "1",
                   "issue_number" => issue.number
                 },
                 project.id
                 project
               )

      assert item.issue_id == issue.id


    test "create_project_item/2 raises when the issue number is unknown", %{project: project} do
      assert_raise Ecto.NoResultsError, fn ->
        Projects.create_project_item(%{"issue_number" => 9999}, project.id)
        Projects.create_project_item(%{"issue_number" => 9999}, project)
      end
    end


      # Regression: a nil issue number used to reach `Repo.get_by!` and raise
      # ArgumentError, which the /api/v3 controller does not rescue.
      assert {:error, %Ecto.Changeset{} = changeset} =
               Projects.create_project_item(%{"values" => %{}}, project.id)
               Projects.create_project_item(%{"values" => %{}}, project)

      assert %{issue_id: ["can't be blank"]} = errors_on(changeset)
      assert Projects.list_project_items(project.id) == []
      assert Projects.list_project_items(project) == []
    end

    test "update_project_item/2 merges into existing values", %{

      {:ok, item} =
        Projects.create_project_item(
          %{"issue_number" => issue.number, "values" => %{"Status" => "Todo", "Size" => "L"}},
          project.id
          project
        )

      assert {:ok, %ProjectItem{} = updated} =

      {:ok, item} =
        Projects.create_project_item(
          %{"issue_number" => issue.number, "values" => %{"Status" => "Todo"}},
          project.id
          project
        )

      assert {:ok, %ProjectItem{} = updated} =

      {:ok, item} =
        Projects.create_project_item(
          %{"issue_number" => issue.number, "values" => %{"Status" => "Todo"}},
          project.id
          project
        )

      assert {:ok, %ProjectItem{} = updated} =

      issue: issue
    } do
      {:ok, item} =
        OpenAgents.ProjectItems.create_project_item(%{
        OpenAgents.ProjectItems.create_project_item(repository(), %{
          project_id: project.id,
          issue_id: issue.id
        })

    import OpenAgents.ProjectsFixtures

    test "list_project_fields/1 is scoped to one project" do
      project = project_fixture(number: 1)
      other = project_fixture(number: 2)
      project = project_fixture(repository(), number: 1)
      other = project_fixture(repository(), number: 2)

      {:ok, mine} =
        Projects.create_project_field(%{

          project_id: other.id
        })

      assert Enum.map(Projects.list_project_fields(project.id), & &1.id) == [mine.id]
      assert Enum.map(Projects.list_project_fields(project), & &1.id) == [mine.id]
    end

    test "list_project_fields/1 returns an empty list for a project with no fields" do
      project = project_fixture()
      assert Projects.list_project_fields(project.id) == []
      project = project_fixture(repository())
      assert Projects.list_project_fields(project) == []
    end

    test "create_project_field/1 with valid data creates a field" do
      project = project_fixture()
      project = project_fixture(repository())

      assert {:ok, %ProjectField{} = field} =
               Projects.create_project_field(%{

372	385		`} = errors_on(changeset)`
373	386		`end`
374	387		`end`
	388	+
	389	+	`defp repository, do: Process.get({__MODULE__, :repository})`
375	390		`end`

  end

  setup do
    repository = Repositories.initial_repository!()
    repository = Repositories.get_by_path!("OpenAgentsInc", "openagents.com")
    owner = plain_user("members-owner")
    {:ok, _membership} = Repositories.add_member(repository, owner, "owner")


  alias OpenAgents.Repositories

  setup do
    initial = Repositories.initial_repository!()
    initial = Repositories.get_by_path!("OpenAgentsInc", "openagents.com")

    {:ok, second} =
      Repositories.create_repository(%{

  end

  test "only active repository members are assignable", %{initial: initial, second: second} do
    _initial_only = repository_user_fixture("initial-only")
    initial_only = repository_user_fixture("initial-only")
    {:ok, _membership} = Repositories.add_member(initial, initial_only, "contributor")

    assert Enum.map(Repositories.list_assignable_users(initial), & &1.github_login) == [
             "initial-only",
             "tenant-member"
             "initial-only"
           ]

    assert Enum.map(Repositories.list_assignable_users(second), & &1.github_login) == [

    second: second,
    user: user
  } do
    {:ok, _membership} = Repositories.add_member(initial, user, "maintainer")
    assert {:ok, project} = Projects.create_project(initial, %{title: "Initial"}, user)
    assert {:ok, second_issue} = Issues.create_issue(second, %{title: "Second"})


    second: second,
    user: user
  } do
    {:ok, _membership} = Repositories.add_member(initial, user, "maintainer")
    assert {:ok, initial_project} = Projects.create_project(initial, %{title: "Initial"}, user)
    assert {:ok, second_project} = Projects.create_project(second, %{title: "Second"}, user)


      )
    )

    repository = Repositories.initial_repository!()
    repository = Repositories.get_by_path!("OpenAgentsInc", "openagents.com")
    bare = ForgeRepos.ensure_repo!(repository.storage_key, repository.default_branch)
    source = Path.join(root, "source")
    File.mkdir_p!(source)

  test "one run removes only its registered accounts, repositories, recordings, and machines" do
    user = repository_user_fixture("cleanup-target")
    unrelated_user = repository_user_fixture("cleanup-unrelated")
    repository = repository_fixture(user)
    repository = cleanup_repository_fixture(user)
    project = project_fixture(repository, user)
    field = project_field_fixture(project)
    machine = machine_fixture(user)

    assert Repo.get(Recording, recording.id) == nil
    assert Repo.get(ProjectField, field.id) == nil
    assert Repo.get(OpenAgents.Accounts.User, unrelated_user.id)
    assert Repositories.initial_repository!()
    assert Repositories.get_by_path!("OpenAgentsInc", "openagents.com")
    assert Repo.aggregate(DisposableResource, :count) == 0

    assert {:ok, %{registered: empty}} = StagingCleanup.preview(@run_id)


  test "registration refuses the canonical repository and administrator accounts" do
    assert {:error, :canonical_repository_forbidden} =
             StagingCleanup.register(@run_id, :repository, Repositories.initial_repository!().id)
             StagingCleanup.register(
               @run_id,
               :repository,
               Repositories.get_by_path!("OpenAgentsInc", "openagents.com").id
             )

    user = repository_user_fixture("cleanup-admin")
    original_ids = Application.get_env(:openagents, :admin_github_ids)


  test "cleanup refuses an account that owns a project outside the registered repositories" do
    user = repository_user_fixture("cleanup-project-owner")
    project = project_fixture(Repositories.initial_repository!(), user)
    repository = Repositories.get_by_path!("OpenAgentsInc", "openagents.com")
    {:ok, _membership} = Repositories.add_member(repository, user, "owner")
    project = project_fixture(repository, user)
    assert {:ok, _registration} = StagingCleanup.register(@run_id, :account, user.id)

    assert {:error, :account_owns_unregistered_project} = StagingCleanup.cleanup(@run_id)

    assert {:error, :staging_cleanup_not_admitted} = StagingCleanup.preview(@run_id)
  end

  defp repository_fixture(user) do
  defp cleanup_repository_fixture(user) do
    {:ok, repository} =
      Repositories.create_repository(%{
        owner: "OpenAgentsStaging",

    conn = start_login(conn)
    {_attempt, state} = attempt_and_state(conn)
    expect_github(502, "empty-repository-person")
    Repositories.initial_repository!() |> Repo.delete!()
    Repositories.get_by_path!("OpenAgentsInc", "openagents.com") |> Repo.delete!()

    authenticated =
      conn


  describe "index" do
    test "GET /api/v3/repos/:owner/:repo/assignees returns the assignable list", %{conn: conn} do
      repository_user_fixture("octocat")
      user = repository_user_fixture("octocat")
      {:ok, _membership} = OpenAgents.Repositories.add_member(repository(), user, "contributor")
      conn = get(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/assignees")

      assert %{"assignees" => [%{"login" => "octocat"}]} = json_response(conn, 200)

  describe "show" do
    test "GET /api/v3/repos/:owner/:repo/assignees/:assignee returns an assignable user",
         %{conn: conn} do
      repository_user_fixture("octocat")
      user = repository_user_fixture("octocat")
      {:ok, _membership} = OpenAgents.Repositories.add_member(repository(), user, "contributor")
      conn = get(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/assignees/octocat")

      assert %{"login" => "octocat"} = json_response(conn, 200)

27	29		`assert json_response(conn, 404) == %{"message" => "Not Found"}`
28	30		`end`
29	31		`end`
	32	+
	33	+	`defp repository do`
	34	+	`OpenAgents.Repositories.get_by_path!("OpenAgentsInc", "openagents.com")`
	35	+	`end`
30	36		`end`

defmodule OpenAgentsWeb.CommentControllerTest do
  use OpenAgentsWeb.ConnCase

  setup %{conn: conn}, do: {:ok, conn: put_forge_api_token(conn, "comments")}
  setup %{conn: conn}, do: {:ok, conn: put_forge_api_token(conn, "comments", repository())}

  alias OpenAgents.Issues

  setup do
    {:ok, issue} = Issues.create_issue(%{title: "Comment target"})
    {:ok, issue} = Issues.create_issue(repository(), %{title: "Comment target"})
    %{issue: issue}
  end


76	76
77	77		`assert response(conn, 204)`
78	78		`end`
	79	+
	80	+	`defp repository do`
	81	+	`OpenAgents.Repositories.get_by_path!("OpenAgentsInc", "openagents.com")`
	82	+	`end`
79	83		`end`

defmodule OpenAgentsWeb.IssueAssigneeControllerTest do
  use OpenAgentsWeb.ConnCase

  setup %{conn: conn}, do: {:ok, conn: put_forge_api_token(conn, "issue-assignees")}
  setup %{conn: conn}, do: {:ok, conn: put_forge_api_token(conn, "issue-assignees", repository())}

  alias OpenAgents.Issues
  import OpenAgents.AccountsFixtures

  setup do
    repository_user_fixture("octocat")
    repository_user_fixture("hubot")
    {:ok, issue} = Issues.create_issue(%{title: "Assignable issue"})
    for login <- ["octocat", "hubot"] do
      user = repository_user_fixture(login)
      {:ok, _membership} = OpenAgents.Repositories.add_member(repository(), user, "contributor")
    end

    {:ok, issue} = Issues.create_issue(repository(), %{title: "Assignable issue"})
    %{issue: issue}
  end



      assert %{"assignees" => [%{"login" => "octocat"}]} = json_response(conn, 200)

      assert [%{"login" => "octocat"}] = Issues.get_issue_by_number!(issue.number).assignees
      assert [%{"login" => "octocat"}] =
               Issues.get_issue_by_number!(repository(), issue.number).assignees
    end

    test "POST .../issues/:issue_number/assignees adds several at once", %{


      assert %{"assignees" => [%{"login" => "hubot"}]} = json_response(conn, 200)

      assert [%{"login" => "hubot"}] = Issues.get_issue_by_number!(issue.number).assignees
      assert [%{"login" => "hubot"}] =
               Issues.get_issue_by_number!(repository(), issue.number).assignees
    end

    test "DELETE .../issues/:issue_number/assignees ignores an assignee that is not set", %{

167	172		`assert json_response(conn, 404) == %{"message" => "Not Found"}`
168	173		`end`
169	174		`end`
	175	+
	176	+	`defp repository do`
	177	+	`OpenAgents.Repositories.get_by_path!("OpenAgentsInc", "openagents.com")`
	178	+	`end`
170	179		`end`

defmodule OpenAgentsWeb.IssueControllerTest do
  use OpenAgentsWeb.ConnCase

  setup %{conn: conn}, do: {:ok, conn: put_forge_api_token(conn, "issues")}
  setup %{conn: conn}, do: {:ok, conn: put_forge_api_token(conn, "issues", repository())}

  alias OpenAgents.Issues
  alias OpenAgents.Repositories

  describe "index" do
    test "GET /api/v3/repos/:owner/:repo/issues lists open issues by default", %{
      conn: conn
    } do
      {:ok, _issue} = Issues.create_issue(%{title: "First issue"})
      {:ok, _issue} = Issues.create_issue(repository(), %{title: "First issue"})

      conn = get(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/issues")


    end

    test "GET /api/v3/repos/:owner/:repo/issues filters by state", %{conn: conn} do
      {:ok, _open_issue} = Issues.create_issue(%{title: "Open issue"})
      {:ok, _closed_issue} = Issues.create_issue(%{title: "Closed issue", state: "closed"})
      {:ok, _open_issue} = Issues.create_issue(repository(), %{title: "Open issue"})

      {:ok, _closed_issue} =
        Issues.create_issue(repository(), %{title: "Closed issue", state: "closed"})

      conn = get(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/issues?state=closed")


    test "GET /api/v3/repos/:owner/:repo/issues/:issue_number returns the issue", %{
      conn: conn
    } do
      {:ok, issue} = Issues.create_issue(%{title: "Show me"})
      {:ok, issue} = Issues.create_issue(repository(), %{title: "Show me"})

      conn = get(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/issues/#{issue.number}")


81	84		`end`
82	85		`end`
83	86
	87	+	`describe "private repository reads" do`
	88	+	`test "a repository member can list and read issues, but an anonymous visitor cannot" do`
	89	+	`private_repository = repository_fixture(%{visibility: "private"})`
	90	+	`{:ok, issue} = Issues.create_issue(private_repository, %{title: "Private issue"})`
	91	+
	92	+	`path =`
	93	+	`"/api/v3/repos/#{private_repository.owner}/#{private_repository.name}/issues"`
	94	+
	95	+	`assert get(build_conn(), path) \|> json_response(404)`
	96	+
	97	+	`member_conn = put_forge_api_token(build_conn(), "private-issue-reader", private_repository)`
	98	+
	99	+	`assert %{"issues" => [%{"title" => "Private issue"}]} =`
	100	+	`get(member_conn, path) \|> json_response(200)`
	101	+
	102	+	`issue_path = path <> "/#{issue.number}"`
	103	+
	104	+	`member_conn = put_forge_api_token(build_conn(), "private-issue-show", private_repository)`
	105	+	`assert %{"title" => "Private issue"} = get(member_conn, issue_path) \|> json_response(200)`
	106	+	`assert get(build_conn(), issue_path) \|> json_response(404)`
	107	+	`end`
	108	+
	109	+	`test "a bearer without repository membership cannot read private issues" do`
	110	+	`private_repository = repository_fixture(%{visibility: "private"})`
	111	+	`{:ok, _issue} = Issues.create_issue(private_repository, %{title: "Private issue"})`
	112	+
	113	+	`conn = put_forge_api_token(build_conn(), "private-issue-nonmember")`
	114	+
	115	+	`conn =`
	116	+	`get(`
	117	+	`conn,`
	118	+	`"/api/v3/repos/#{private_repository.owner}/#{private_repository.name}/issues"`
	119	+	`)`
	120	+
	121	+	`assert json_response(conn, 404)`
	122	+	`end`
	123	+	`end`
	124	+
84	125		`describe "update" do`
85	126		`test "PATCH /api/v3/repos/:owner/:repo/issues/:issue_number closes an issue", %{`
86	127		`conn: conn`
87	128		`} do`
88		-	`{:ok, issue} = Issues.create_issue(%{title: "Close me"})`
	129	+	`{:ok, issue} = Issues.create_issue(repository(), %{title: "Close me"})`
89	130
90	131		`conn =`
91	132		`patch(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/issues/#{issue.number}", %{`

96	137		`assert n == issue.number`
97	138		`end`
98	139		`end`
	140	+
	141	+	`defp repository do`
	142	+	`Repositories.get_by_path!("OpenAgentsInc", "openagents.com")`
	143	+	`end`
99	144		`end`

defmodule OpenAgentsWeb.IssueLabelControllerTest do
  use OpenAgentsWeb.ConnCase

  setup %{conn: conn}, do: {:ok, conn: put_forge_api_token(conn, "issue-labels")}
  setup %{conn: conn}, do: {:ok, conn: put_forge_api_token(conn, "issue-labels", repository())}

  import OpenAgents.LabelsFixtures


  alias OpenAgents.Labels

  setup do
    {:ok, issue} = Issues.create_issue(%{title: "Labelled issue"})
    {:ok, issue} = Issues.create_issue(repository(), %{title: "Labelled issue"})
    %{issue: issue}
  end


      conn: conn,
      issue: issue
    } do
      label_fixture(%{name: "bug", color: "d73a4a"})
      label_fixture(repository(), %{name: "bug", color: "d73a4a"})
      {:ok, _issue} = Issues.add_labels(issue, ["bug"])

      conn =

      conn: conn,
      issue: issue
    } do
      label_fixture(%{name: "bug", color: "d73a4a"})
      label_fixture(repository(), %{name: "bug", color: "d73a4a"})

      conn =
        post(

      assert %{"labels" => [label]} = json_response(conn, 200)
      assert label["name"] == "bug"

      assert [%{"name" => "bug"}] = Issues.get_issue_by_number!(issue.number).labels
      assert [%{"name" => "bug"}] = Issues.get_issue_by_number!(repository(), issue.number).labels
    end

    test "POST .../issues/:issue_number/labels adds several labels at once", %{
      conn: conn,
      issue: issue
    } do
      label_fixture(%{name: "bug", color: "d73a4a"})
      label_fixture(%{name: "docs", color: "0075ca"})
      label_fixture(repository(), %{name: "bug", color: "d73a4a"})
      label_fixture(repository(), %{name: "docs", color: "0075ca"})

      conn =
        post(

      conn: conn,
      issue: issue
    } do
      label_fixture(%{name: "bug", color: "d73a4a"})
      label_fixture(repository(), %{name: "bug", color: "d73a4a"})
      {:ok, _issue} = Issues.add_labels(issue, ["bug"])

      conn =

        )

      assert %{"labels" => [%{"name" => "never-created"}]} = json_response(conn, 200)
      assert [%{"name" => "never-created"}] = Issues.get_issue_by_number!(issue.number).labels

      assert [%{"name" => "never-created"}] =
               Issues.get_issue_by_number!(repository(), issue.number).labels

      refute Labels.get_label_by_name!(
               OpenAgents.Repositories.initial_repository!(),
               OpenAgents.Repositories.get_by_path!("OpenAgentsInc", "openagents.com"),
               "never-created"
             ).color == ""
    end

        )

      assert %{"errors" => %{"name" => [_message]}} = json_response(conn, 422)
      assert Issues.get_issue_by_number!(issue.number).labels == []
      assert Issues.get_issue_by_number!(repository(), issue.number).labels == []
    end

    test "POST .../issues/:issue_number/labels returns 404 for a missing issue", %{conn: conn} do

      conn: conn,
      issue: issue
    } do
      label_fixture(%{name: "bug", color: "d73a4a"})
      label_fixture(%{name: "docs", color: "0075ca"})
      label_fixture(repository(), %{name: "bug", color: "d73a4a"})
      label_fixture(repository(), %{name: "docs", color: "0075ca"})
      {:ok, _issue} = Issues.add_labels(issue, ["bug", "docs"])

      conn =

      assert %{"labels" => [label]} = json_response(conn, 200)
      assert label["name"] == "docs"

      assert [%{"name" => "docs"}] = Issues.get_issue_by_number!(issue.number).labels
      assert [%{"name" => "docs"}] =
               Issues.get_issue_by_number!(repository(), issue.number).labels
    end

    test "DELETE .../issues/:issue_number/labels/:name decodes an escaped name", %{
      conn: conn,
      issue: issue
    } do
      label_fixture(%{name: "good first issue", color: "7057ff"})
      label_fixture(repository(), %{name: "good first issue", color: "7057ff"})
      {:ok, _issue} = Issues.add_labels(issue, ["good first issue"])

      conn =

      conn: conn,
      issue: issue
    } do
      label_fixture(%{name: "bug", color: "d73a4a"})
      label_fixture(repository(), %{name: "bug", color: "d73a4a"})
      {:ok, _issue} = Issues.add_labels(issue, ["bug"])

      conn =

        )

      assert json_response(conn, 404)
      assert [%{"name" => "bug"}] = Issues.get_issue_by_number!(issue.number).labels
      assert [%{"name" => "bug"}] = Issues.get_issue_by_number!(repository(), issue.number).labels
    end

    test "DELETE .../issues/:issue_number/labels/:name returns 404 for a missing issue", %{

235	238		`assert json_response(conn, 404) == %{"message" => "Not Found"}`
236	239		`end`
237	240		`end`
	241	+
	242	+	`defp repository do`
	243	+	`OpenAgents.Repositories.get_by_path!("OpenAgentsInc", "openagents.com")`
	244	+	`end`
238	245		`end`

defmodule OpenAgentsWeb.LabelControllerTest do
  use OpenAgentsWeb.ConnCase

  setup %{conn: conn}, do: {:ok, conn: put_forge_api_token(conn, "labels")}
  setup %{conn: conn}, do: {:ok, conn: put_forge_api_token(conn, "labels", repository())}

  import OpenAgents.LabelsFixtures



  describe "index" do
    test "GET /api/v3/repos/:owner/:repo/labels lists labels", %{conn: conn} do
      label_fixture(%{name: "bug", color: "d73a4a"})
      label_fixture(repository(), %{name: "bug", color: "d73a4a"})

      conn = get(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/labels")


    end

    test "GET /api/v3/repos/:owner/:repo/labels renders a repo-scoped url", %{conn: conn} do
      label_fixture(%{name: "bug", color: "d73a4a"})
      label_fixture(repository(), %{name: "bug", color: "d73a4a"})

      conn = get(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/labels")


               "default" => false
             } = json_response(conn, 201)

      assert Labels.get_label_by_name!("enhancement").color == "a2eeef"
      assert Labels.get_label_by_name!(repository(), "enhancement").color == "a2eeef"
    end

    test "POST /api/v3/repos/:owner/:repo/labels returns 422 without a color", %{conn: conn} do

        color: "ffffff"
      })

      label = Labels.get_label_by_name!("scoped")
      label = Labels.get_label_by_name!(repository(), "scoped")
      refute Map.has_key?(label, :owner)
      refute Map.has_key?(label, :repo)
    end


  describe "show" do
    test "GET /api/v3/repos/:owner/:repo/labels/:name returns the label", %{conn: conn} do
      label = label_fixture(%{name: "bug", color: "d73a4a"})
      label = label_fixture(repository(), %{name: "bug", color: "d73a4a"})

      conn = get(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/labels/bug")


    end

    test "GET /api/v3/repos/:owner/:repo/labels/:name decodes an escaped name", %{conn: conn} do
      label_fixture(%{name: "good first issue", color: "7057ff"})
      label_fixture(repository(), %{name: "good first issue", color: "7057ff"})

      conn = get(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/labels/good first issue")


    # The advertised URL is percent-encoded the way a path is, so a label
    # with a space in its name advertises a link that resolves.
    test "the rendered url round-trips through the show endpoint", %{conn: conn} do
      label_fixture(%{name: "good first issue", color: "7057ff"})
      label_fixture(repository(), %{name: "good first issue", color: "7057ff"})

      conn = get(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/labels")



  describe "update" do
    test "PATCH /api/v3/repos/:owner/:repo/labels/:name updates the color", %{conn: conn} do
      label_fixture(%{name: "bug", color: "d73a4a"})
      label_fixture(repository(), %{name: "bug", color: "d73a4a"})

      conn =
        patch(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/labels/bug", %{color: "000000"})

      assert %{"name" => "bug", "color" => "000000"} = json_response(conn, 200)
      assert Labels.get_label_by_name!("bug").color == "000000"
      assert Labels.get_label_by_name!(repository(), "bug").color == "000000"
    end

    test "PATCH /api/v3/repos/:owner/:repo/labels/:name updates the description", %{conn: conn} do
      label_fixture(%{name: "bug", color: "d73a4a", description: "old"})
      label_fixture(repository(), %{name: "bug", color: "d73a4a", description: "old"})

      conn =
        patch(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/labels/bug", %{

    # GitHub renames through `new_name`; the name in the path identifies the
    # label and `new_name` is what it becomes.
    test "PATCH /api/v3/repos/:owner/:repo/labels/:name renames with new_name", %{conn: conn} do
      label_fixture(%{name: "bug", color: "d73a4a"})
      label_fixture(repository(), %{name: "bug", color: "d73a4a"})

      conn =
        patch(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/labels/bug", %{

        })

      assert json_response(conn, 200)["name"] == "defect"
      assert Labels.get_label_by_name!("defect").color == "d73a4a"
      assert Labels.get_label_by_name!(repository(), "defect").color == "d73a4a"

      assert_raise Ecto.NoResultsError, fn -> Labels.get_label_by_name!("bug") end
      assert_raise Ecto.NoResultsError, fn -> Labels.get_label_by_name!(repository(), "bug") end
    end

    test "PATCH /api/v3/repos/:owner/:repo/labels/:name returns 422 for a blank color", %{
      conn: conn
    } do
      label_fixture(%{name: "bug", color: "d73a4a"})
      label_fixture(repository(), %{name: "bug", color: "d73a4a"})

      conn =
        conn

        |> patch(~p"/api/v3/repos/OpenAgentsInc/openagents.com/labels/bug", ~s({"color": null}))

      assert %{"errors" => %{"color" => _}} = json_response(conn, 422)
      assert Labels.get_label_by_name!("bug").color == "d73a4a"
      assert Labels.get_label_by_name!(repository(), "bug").color == "d73a4a"
    end

    test "PATCH /api/v3/repos/:owner/:repo/labels/:name returns 404 when missing", %{conn: conn} do


  describe "delete" do
    test "DELETE /api/v3/repos/:owner/:repo/labels/:name returns 204", %{conn: conn} do
      label_fixture(%{name: "bug", color: "d73a4a"})
      label_fixture(repository(), %{name: "bug", color: "d73a4a"})

      conn = delete(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/labels/bug")

      assert response(conn, 204) == ""
      assert Labels.list_labels() == []
      assert Labels.list_labels(repository()) == []
    end

    test "DELETE /api/v3/repos/:owner/:repo/labels/:name returns 404 when missing", %{conn: conn} do

195	195		`assert json_response(conn, 404) == %{"message" => "Not Found"}`
196	196		`end`
197	197		`end`
	198	+
	199	+	`defp repository do`
	200	+	`OpenAgents.Repositories.get_by_path!("OpenAgentsInc", "openagents.com")`
	201	+	`end`
198	202		`end`

defmodule OpenAgentsWeb.MilestoneControllerTest do
  use OpenAgentsWeb.ConnCase

  setup %{conn: conn}, do: {:ok, conn: put_forge_api_token(conn, "milestones")}
  setup %{conn: conn}, do: {:ok, conn: put_forge_api_token(conn, "milestones", repository())}

  import OpenAgents.MilestonesFixtures



  describe "index" do
    test "GET /api/v3/repos/:owner/:repo/milestones lists milestones", %{conn: conn} do
      milestone_fixture(%{title: "v1.0", state: "open"})
      milestone_fixture(repository(), %{title: "v1.0", state: "open"})

      conn = get(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/milestones")


    end

    test "GET /api/v3/repos/:owner/:repo/milestones renders issue counts and url", %{conn: conn} do
      milestone = milestone_fixture(%{title: "v1.0"})
      {:ok, _open_issue} = Issues.create_issue(%{title: "Open", milestone: milestone.number})
      milestone = milestone_fixture(repository(), %{title: "v1.0"})

      {:ok, _open_issue} =
        Issues.create_issue(repository(), %{title: "Open", milestone: milestone.number})

      {:ok, _closed_issue} =
        Issues.create_issue(%{title: "Closed", milestone: milestone.number, state: "closed"})
        Issues.create_issue(repository(), %{
          title: "Closed",
          milestone: milestone.number,
          state: "closed"
        })

      conn = get(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/milestones")


               "number" => number
             } = json_response(conn, 201)

      assert Milestones.get_milestone_by_number!(number).title == "v2.0"
      assert Milestones.get_milestone_by_number!(repository(), number).title == "v2.0"
    end

    test "POST /api/v3/repos/:owner/:repo/milestones assigns sequential numbers", %{conn: conn} do

        })

      assert %{"errors" => %{"title" => _}} = json_response(conn, 422)
      assert Milestones.list_milestones() == []
      assert Milestones.list_milestones(repository()) == []
    end
  end

  describe "show" do
    test "GET /api/v3/repos/:owner/:repo/milestones/:milestone_number returns it", %{conn: conn} do
      milestone = milestone_fixture(%{title: "Show me"})
      milestone = milestone_fixture(repository(), %{title: "Show me"})

      conn =
        get(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/milestones/#{milestone.number}")


  describe "update" do
    test "PATCH /api/v3/repos/:owner/:repo/milestones/:milestone_number closes it", %{conn: conn} do
      milestone = milestone_fixture(%{title: "Close me", state: "open"})
      milestone = milestone_fixture(repository(), %{title: "Close me", state: "open"})

      conn =
        patch(

        )

      assert json_response(conn, 200)["state"] == "closed"
      assert Milestones.get_milestone_by_number!(milestone.number).state == "closed"
      assert Milestones.get_milestone_by_number!(repository(), milestone.number).state == "closed"
    end

    test "PATCH /api/v3/repos/:owner/:repo/milestones/:milestone_number retitles it", %{
      conn: conn
    } do
      milestone = milestone_fixture(%{title: "Old title"})
      milestone = milestone_fixture(repository(), %{title: "Old title"})

      conn =
        patch(


    test "PATCH /api/v3/repos/:owner/:repo/milestones/:milestone_number returns 422 for a blank title",
         %{conn: conn} do
      milestone = milestone_fixture(%{title: "Keep me"})
      milestone = milestone_fixture(repository(), %{title: "Keep me"})

      conn =
        conn

        )

      assert %{"errors" => %{"title" => _}} = json_response(conn, 422)
      assert Milestones.get_milestone_by_number!(milestone.number).title == "Keep me"

      assert Milestones.get_milestone_by_number!(repository(), milestone.number).title ==
               "Keep me"
    end

    test "PATCH /api/v3/repos/:owner/:repo/milestones/:milestone_number returns 404 when missing",

    test "DELETE /api/v3/repos/:owner/:repo/milestones/:milestone_number returns 204", %{
      conn: conn
    } do
      milestone = milestone_fixture(%{title: "Delete me"})
      milestone = milestone_fixture(repository(), %{title: "Delete me"})

      conn =
        delete(

        )

      assert response(conn, 204) == ""
      assert Milestones.list_milestones() == []
      assert Milestones.list_milestones(repository()) == []
    end

    test "DELETE /api/v3/repos/:owner/:repo/milestones/:milestone_number returns 404 when missing",

185	193		`assert json_response(conn, 404) == %{"message" => "Not Found"}`
186	194		`end`
187	195		`end`
	196	+
	197	+	`defp repository do`
	198	+	`OpenAgents.Repositories.get_by_path!("OpenAgentsInc", "openagents.com")`
	199	+	`end`
188	200		`end`

    end)

    shas = seed_repo("openagents.com")
    repository = Repositories.initial_repository!()
    repository = Repositories.get_by_path!("OpenAgentsInc", "openagents.com")

    {:ok, repository: repository, shas: shas}
  end

  end

  test "issue cards render from the public issue path", %{conn: conn} do
    {:ok, issue} = Issues.create_issue(%{"title" => "Carded issue"})
    {:ok, issue} = Issues.create_issue(repository(), %{"title" => "Carded issue"})
    card = OpenAgentsWeb.OG.issue("OpenAgentsInc", "openagents.com", issue)

    assert response(get(conn, signed_url(card)), 200) == @marker_png


    real_path =
      OpenAgentsWeb.OG.request_path(
        OpenAgentsWeb.OG.repo_card_for(Repositories.initial_repository!())
        OpenAgentsWeb.OG.repo_card_for(
          Repositories.get_by_path!("OpenAgentsInc", "openagents.com")
        )
      )

    bad_signature = real_path <> "?sig=bogus"

  end

  test "an issue page emits an issue-specific card URL", %{conn: conn} do
    {:ok, issue} = Issues.create_issue(%{"title" => "Shared on social"})
    {:ok, issue} = Issues.create_issue(repository(), %{"title" => "Shared on social"})

    {:ok, _view, html} = live(conn, ~p"/OpenAgentsInc/openagents.com/issues/#{issue.number}")


328	330		`File.rm(input)`
329	331		`end`
330	332		`end`
	333	+
	334	+	`defp repository do`
	335	+	`OpenAgents.Repositories.get_by_path!("OpenAgentsInc", "openagents.com")`
	336	+	`end`
331	337		`end`

defmodule OpenAgentsWeb.ProjectControllerTest do
  use OpenAgentsWeb.ConnCase

  setup %{conn: conn}, do: {:ok, conn: put_forge_api_token(conn, "projects", "alice")}

  import OpenAgents.ProjectFieldsFixtures
  import OpenAgents.ProjectItemsFixtures
  import OpenAgents.ProjectsFixtures

  alias OpenAgents.Issues
  alias OpenAgents.Projects

  @owner "ProjectTestOrg"
  @repo "project-api"

  setup %{conn: conn} do
    user = github_user("api-token-projects", "alice")

    repository =
      repository_with_member_fixture(user, %{
        owner: @owner,
        name: @repo,
        visibility: "private"
      })

    Process.put({__MODULE__, :repository}, repository)
    on_exit(fn -> Process.delete({__MODULE__, :repository}) end)

    {:ok,
     conn: put_forge_api_token(conn, "projects", "alice"), repository: repository, user: user}
  end

  describe "index" do
    test "GET /api/v3/users/:username/projectsV2 lists that user's projects", %{conn: conn} do
    test "GET /api/v3/repos/:owner/:repo/projectsV2 lists the repository's projects", %{
      conn: conn
    } do
      project_fixture(%{title: "Roadmap", owner: "alice", state: "open"})

      conn = get(conn, ~p"/api/v3/users/alice/projectsV2")
      conn = get(conn, ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2")

      assert %{"projects" => [project]} = json_response(conn, 200)
      assert project["title"] == "Roadmap"

      assert project["state"] == "open"
    end

    test "GET /api/v3/users/:username/projectsV2 excludes other owners' projects", %{conn: conn} do
    test "GET /api/v3/repos/:owner/:repo/projectsV2 excludes another repository", %{conn: conn} do
      project_fixture(%{title: "Mine", owner: "alice"})
      project_fixture(%{title: "Theirs", owner: "bob"})
      other_repository = repository_fixture(%{owner: "Elsewhere", name: "other-projects"})

      conn = get(conn, ~p"/api/v3/users/alice/projectsV2")
      {:ok, _project} =
        Projects.create_project(other_repository, %{title: "Theirs", owner: "bob"})

      conn = get(conn, ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2")

      assert %{"projects" => [%{"title" => "Mine"}]} = json_response(conn, 200)
    end

    test "GET /api/v3/users/:username/projectsV2 returns an empty list for an unknown user", %{
      conn: conn
    } do
      conn = get(conn, ~p"/api/v3/users/nobody/projectsV2")

      assert json_response(conn, 200) == %{"projects" => []}
    test "GET /api/v3/repos/:owner/:repo/projectsV2 hides a private repository from a non-member" do
      conn = get(build_conn(), ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2")
      assert json_response(conn, 404) == %{"message" => "Not Found"}
    end
  end

  describe "create" do
    test "POST /api/v3/:owner/projectsV2 creates a project", %{conn: conn} do
      conn = post(conn, ~p"/api/v3/alice/projectsV2", %{title: "New board"})
    test "POST /api/v3/repos/:owner/:repo/projectsV2 creates a project", %{conn: conn} do
      conn =
        post(conn, ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2", %{
          title: "New board"
        })

      assert %{"title" => "New board", "owner" => "alice", "number" => number} =
               json_response(conn, 201)

      assert Projects.get_project_by_number!(number).title == "New board"
      assert Projects.get_project_by_number!(repository(), number).title == "New board"
    end

    test "POST /api/v3/:owner/projectsV2 takes the owner from the path", %{conn: conn} do
      conn = post(conn, ~p"/api/v3/alice/projectsV2", %{title: "Board", owner: "mallory"})
    test "POST /api/v3/repos/:owner/:repo/projectsV2 ignores repository override params", %{
      conn: conn
    } do
      conn =
        post(conn, ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2", %{
          title: "Board",
          owner: "mallory",
          repo: "elsewhere"
        })

      assert json_response(conn, 201)["owner"] == "alice"
    end

    test "POST /api/v3/:owner/projectsV2 returns 422 without a title", %{conn: conn} do
      conn = post(conn, ~p"/api/v3/alice/projectsV2", %{})
    test "POST /api/v3/repos/:owner/:repo/projectsV2 returns 422 without a title", %{
      conn: conn
    } do
      conn = post(conn, ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2", %{})

      assert %{"errors" => %{"title" => _}} = json_response(conn, 422)
      assert Projects.list_projects() == []
      assert Projects.list_projects(repository()) == []
    end
  end

  describe "show" do
    test "GET /api/v3/users/:username/projectsV2/:project_number returns the project", %{
    test "GET /api/v3/repos/:owner/:repo/projectsV2/:project_number returns the project", %{
      conn: conn
    } do
      project = project_fixture(%{title: "Roadmap", owner: "alice"})

      conn = get(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}")
      conn = get(conn, ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}")

      assert %{"title" => "Roadmap", "id" => id} = json_response(conn, 200)
      assert id == project.id
    end

    test "GET /api/v3/users/:username/projectsV2/:project_number returns 404 when missing", %{
    test "GET /api/v3/repos/:owner/:repo/projectsV2/:project_number returns 404 when missing", %{
      conn: conn
    } do
      conn = get(conn, ~p"/api/v3/users/alice/projectsV2/999999")
      conn = get(conn, ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/999999")

      assert json_response(conn, 404) == %{"message" => "Not Found"}
    end

    } do
      project = project_fixture(%{title: "Roadmap", owner: "alice"})

      conn = get(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}/items")
      conn =
        get(conn, ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/items")

      assert json_response(conn, 200) == %{"items" => []}
    end

      project = project_fixture(%{title: "Roadmap", owner: "alice"})
      item = project_item_fixture(%{project_id: project.id, values: %{"Status" => "Todo"}})

      conn = get(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}/items")
      conn =
        get(conn, ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/items")

      assert %{"items" => [rendered]} = json_response(conn, 200)
      assert rendered["id"] == item.id

    test "GET .../projectsV2/:project_number/items returns 404 for a missing project", %{
      conn: conn
    } do
      conn = get(conn, ~p"/api/v3/users/alice/projectsV2/999999/items")
      conn = get(conn, ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/999999/items")

      assert json_response(conn, 404) == %{"message" => "Not Found"}
    end

  describe "create_item" do
    setup do
      project = project_fixture(%{title: "Roadmap", owner: "alice"})
      {:ok, issue} = Issues.create_issue(%{title: "Trackable issue"})
      {:ok, issue} = create_issue(%{title: "Trackable issue"})
      %{project: project, issue: issue}
    end


      issue: issue
    } do
      conn =
        post(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}/items", %{
          issue_number: issue.number
        })
        post(
          conn,
          ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/items",
          %{
            issue_number: issue.number
          }
        )

      assert %{"items" => [item]} = json_response(conn, 201)
      assert item["issue_id"] == issue.id

      assert [%{issue_id: issue_id}] = Projects.list_project_items(project.id)
      assert [%{issue_id: issue_id}] = Projects.list_project_items(project)
      assert issue_id == issue.id
    end


      issue: issue
    } do
      conn =
        post(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}/items", %{
          issue_number: issue.number,
          values: %{"Status" => "In Progress"}
        })
        post(
          conn,
          ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/items",
          %{
            issue_number: issue.number,
            values: %{"Status" => "In Progress"}
          }
        )

      assert %{"items" => [%{"values" => %{"Status" => "In Progress"}}]} =
               json_response(conn, 201)

      issue: issue
    } do
      conn =
        post(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}/items", %{
          issue_number: issue.number,
          values: "not-a-map"
        })
        post(
          conn,
          ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/items",
          %{
            issue_number: issue.number,
            values: "not-a-map"
          }
        )

      assert %{"errors" => %{"values" => _}} = json_response(conn, 422)
      assert Projects.list_project_items(project.id) == []
      assert Projects.list_project_items(project) == []
    end

    test "POST .../projectsV2/:project_number/items returns 422 without an issue_number", %{
      conn: conn,
      project: project
    } do
      conn = post(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}/items", %{})
      conn =
        post(
          conn,
          ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/items",
          %{}
        )

      assert %{"errors" => %{"issue_number" => _}} = json_response(conn, 422)
      assert Projects.list_project_items(project.id) == []
      assert Projects.list_project_items(project) == []
    end

    test "POST .../projectsV2/:project_number/items returns 422 for a non-numeric issue_number",
         %{conn: conn, project: project} do
      conn =
        post(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}/items", %{
          issue_number: "not-a-number"
        })
        post(
          conn,
          ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/items",
          %{
            issue_number: "not-a-number"
          }
        )

      assert %{"errors" => %{"issue_number" => _}} = json_response(conn, 422)
      assert Projects.list_project_items(project.id) == []
      assert Projects.list_project_items(project) == []
    end

    test "POST .../projectsV2/:project_number/items returns 404 for an unknown issue", %{

      project: project
    } do
      conn =
        post(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}/items", %{
          issue_number: 999_999
        })
        post(
          conn,
          ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/items",
          %{
            issue_number: 999_999
          }
        )

      assert json_response(conn, 404) == %{"message" => "Not Found"}
    end

      issue: issue
    } do
      conn =
        post(conn, ~p"/api/v3/users/alice/projectsV2/999999/items", %{issue_number: issue.number})
        post(conn, ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/999999/items", %{
          issue_number: issue.number
        })

      assert json_response(conn, 404) == %{"message" => "Not Found"}
    end

      item: item
    } do
      conn =
        patch(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}/items/#{item.id}", %{
          values: %{"Status" => "Done"}
        })
        patch(
          conn,
          ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/items/#{item.id}",
          %{
            values: %{"Status" => "Done"}
          }
        )

      assert %{"items" => [%{"values" => %{"Status" => "Done"}}]} = json_response(conn, 200)
      assert Projects.get_project_item!(item.id).values == %{"Status" => "Done"}
      assert Projects.get_project_item!(project, item.id).values == %{"Status" => "Done"}
    end

    test "PATCH .../items/:item_id keeps values it was not asked to change", %{

      item: item
    } do
      conn =
        patch(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}/items/#{item.id}", %{
          values: %{"Priority" => "P1"}
        })
        patch(
          conn,
          ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/items/#{item.id}",
          %{
            values: %{"Priority" => "P1"}
          }
        )

      assert %{"items" => [%{"values" => values}]} = json_response(conn, 200)
      assert values == %{"Status" => "Todo", "Priority" => "P1"}

      item: item
    } do
      conn =
        patch(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}/items/#{item.id}", %{
          values: "not-a-map"
        })
        patch(
          conn,
          ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/items/#{item.id}",
          %{
            values: "not-a-map"
          }
        )

      assert %{"errors" => %{"values" => _}} = json_response(conn, 422)
      assert Projects.get_project_item!(item.id).values == %{"Status" => "Todo"}
      assert Projects.get_project_item!(project, item.id).values == %{"Status" => "Todo"}
    end

    test "PATCH .../items/:item_id returns 404 for a missing item", %{

      project: project
    } do
      conn =
        patch(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}/items/999999", %{
          values: %{"Status" => "Done"}
        })
        patch(
          conn,
          ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/items/999999",
          %{
            values: %{"Status" => "Done"}
          }
        )

      assert json_response(conn, 404) == %{"message" => "Not Found"}
    end

    } do
      project = project_fixture(%{title: "Roadmap", owner: "alice"})

      conn = get(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}/fields")
      conn =
        get(
          conn,
          ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/fields"
        )

      assert json_response(conn, 200) == %{"fields" => []}
    end

          options: %{"values" => ["Todo", "Done"]}
        })

      conn = get(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}/fields")
      conn =
        get(
          conn,
          ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/fields"
        )

      assert %{"fields" => [rendered]} = json_response(conn, 200)
      assert rendered["id"] == field.id

    test "GET .../projectsV2/:project_number/fields returns 404 for a missing project", %{
      conn: conn
    } do
      conn = get(conn, ~p"/api/v3/users/alice/projectsV2/999999/fields")
      conn = get(conn, ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/999999/fields")

      assert json_response(conn, 404) == %{"message" => "Not Found"}
    end

      project = project_fixture(%{title: "Roadmap", owner: "alice"})

      conn =
        post(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}/fields", %{
          name: "Status",
          data_type: "single_select",
          options: %{values: ["To Do", "In Progress", "Done"]}
        })
        post(
          conn,
          ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/fields",
          %{
            name: "Status",
            data_type: "single_select",
            options: %{values: ["To Do", "In Progress", "Done"]}
          }
        )

      assert %{
               "fields" => [

    } do
      project = project_fixture(%{title: "Roadmap", owner: "alice"})

      conn = post(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}/fields", %{})
      conn =
        post(
          conn,
          ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/fields",
          %{}
        )

      assert %{"errors" => errors} = json_response(conn, 422)
      assert Map.has_key?(errors, "name")

      other_project = project_fixture(%{title: "Other", owner: "alice"})

      conn =
        post(conn, ~p"/api/v3/users/alice/projectsV2/#{project.number}/fields", %{
          name: "Status",
          data_type: "single_select",
          project_id: other_project.id
        })
        post(
          conn,
          ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/fields",
          %{
            name: "Status",
            data_type: "single_select",
            project_id: other_project.id
          }
        )

      assert json_response(conn, 201)
      assert [%{project_id: project_id}] = Projects.list_project_fields(project)

    end
  end

  describe "owner-path authorization" do
    test "another username cannot read or mutate a project through any project action", %{
      conn: conn
    } do
  describe "repository authorization" do
    test "a non-member cannot read or mutate a private repository's project" do
      project = project_fixture(%{title: "Alice only", owner: "alice"})
      {:ok, issue} = Issues.create_issue(%{title: "Tracked"})
      {:ok, issue} = create_issue(%{title: "Tracked"})
      mallory_conn = put_forge_api_token(build_conn(), "project-mallory", "mallory")

      {:ok, item} =
        Projects.create_project_item(%{"issue_number" => issue.number}, project)

          data_type: "single_select"
        })

      assert get(conn, ~p"/api/v3/users/bob/projectsV2/#{project.number}")
      assert get(
               mallory_conn,
               ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}"
             )
             |> json_response(404) == %{"message" => "Not Found"}

      assert get(recycle(conn), ~p"/api/v3/users/bob/projectsV2/#{project.number}/items")
      assert get(
               recycle(mallory_conn),
               ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/items"
             )
             |> json_response(404) == %{"message" => "Not Found"}

      assert get(recycle(conn), ~p"/api/v3/users/bob/projectsV2/#{project.number}/fields")
      assert get(
               recycle(mallory_conn),
               ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/fields"
             )
             |> json_response(404) == %{"message" => "Not Found"}

      assert post(
               recycle(conn),
               ~p"/api/v3/users/bob/projectsV2/#{project.number}/items",
               recycle(mallory_conn),
               ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/items",
               %{issue_number: issue.number}
             )
             |> json_response(404) == %{"message" => "Not Found"}

      assert patch(
               recycle(conn),
               ~p"/api/v3/users/bob/projectsV2/#{project.number}/items/#{item.id}",
               recycle(mallory_conn),
               ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/items/#{item.id}",
               %{values: %{"Status" => "Done"}}
             )
             |> json_response(404) == %{"message" => "Not Found"}

      assert post(
               recycle(conn),
               ~p"/api/v3/users/bob/projectsV2/#{project.number}/fields",
               recycle(mallory_conn),
               ~p"/api/v3/repos/ProjectTestOrg/project-api/projectsV2/#{project.number}/fields",
               %{name: "Priority", data_type: "single_select"}
             )
             |> json_response(404) == %{"message" => "Not Found"}

      assert Projects.get_project_item!(item.id).values == %{}
      assert Projects.get_project_item!(project, item.id).values == %{}
    end

    test "a token owner cannot create a project for another username", %{conn: conn} do
      assert post(conn, ~p"/api/v3/bob/projectsV2", %{title: "Not Bob's"})
    test "a token owner cannot create a project in another repository", %{conn: conn} do
      other_repository =
        repository_fixture(%{owner: "OtherOrg", name: "other-private", visibility: "private"})

      assert post(conn, ~p"/api/v3/repos/OtherOrg/other-private/projectsV2", %{
               title: "Not Alice's"
             })
             |> json_response(404) == %{"message" => "Not Found"}

      assert Projects.list_projects() == []
      assert Projects.list_projects(other_repository) == []
    end
  end

  defp repository, do: Process.get({__MODULE__, :repository})

  defp project_fixture(attrs) do
    OpenAgents.ProjectsFixtures.project_fixture(repository(), attrs)
  end

  defp project_item_fixture(attrs) do
    OpenAgents.ProjectItemsFixtures.project_item_fixture(repository(), attrs)
  end

  defp project_field_fixture(attrs) do
    OpenAgents.ProjectFieldsFixtures.project_field_fixture(repository(), attrs)
  end

  defp create_issue(attrs), do: Issues.create_issue(repository(), attrs)
end


  setup %{conn: conn} do
    conn = put_forge_api_token(conn, "repository-isolation")
    initial = Repositories.initial_repository!()
    initial = Repositories.get_by_path!("OpenAgentsInc", "openagents.com")

    {:ok, second} =
      Repositories.create_repository(%{


  test "an authenticated account sees the dashboard before the first import", %{conn: conn} do
    conn = log_in_github_user(conn, "authenticated-empty-home-user")
    Repositories.initial_repository!() |> Repo.delete!()
    Repositories.get_by_path!("OpenAgentsInc", "openagents.com") |> Repo.delete!()

    html = html_response(get(conn, ~p"/"), 200)


  import OpenAgents.AccountsFixtures

  setup %{conn: conn} do
    {:ok, conn: log_in_github_user(conn, "assignee-index")}
    {:ok, conn: log_in_repository_user(conn, "assignee-index", repository())}
  end

  test "mounts with an honest empty state when no issue has an assignee", %{conn: conn} do

  end

  test "tallies assignees across open and closed issues, most-assigned first", %{conn: conn} do
    repository_user_fixture("ada-assignee")
    repository_user_fixture("grace-assignee")
    for login <- ["ada-assignee", "grace-assignee"] do
      user = repository_user_fixture(login)
      {:ok, _membership} = OpenAgents.Repositories.add_member(repository(), user, "contributor")
    end

    {:ok, _first} =
      Issues.create_issue(%{
      Issues.create_issue(repository(), %{
        "title" => "First",
        "assignees" => ["ada-assignee", "grace-assignee"]
      })

    {:ok, _second} =
      Issues.create_issue(%{"title" => "Second", "assignees" => ["ada-assignee"]})
      Issues.create_issue(repository(), %{"title" => "Second", "assignees" => ["ada-assignee"]})

    {:ok, third} =
      Issues.create_issue(%{"title" => "Third", "assignees" => ["ada-assignee"]})
      Issues.create_issue(repository(), %{"title" => "Third", "assignees" => ["ada-assignee"]})

    # A closed issue still counts: the view lists `state: "all"`.
    {:ok, _} = Issues.update_issue(third, %{"state" => "closed"})

56	58
57	59		`refute to == "/OpenAgentsInc/openagents.com/assignees"`
58	60		`end`
	61	+
	62	+	`defp repository do`
	63	+	`OpenAgents.Repositories.get_by_path!("OpenAgentsInc", "openagents.com")`
	64	+	`end`
59	65		`end`

    {path, _flash} = assert_redirect(view)
    number = path |> String.split("/") |> List.last() |> String.to_integer()

    Issues.get_issue_by_number!(Repositories.initial_repository!(), number)
    Issues.get_issue_by_number!(
      Repositories.get_by_path!("OpenAgentsInc", "openagents.com"),
      number
    )
  end

  describe "anonymous visitors" do
    test "read a public issue and its timeline without any write controls" do
      {:ok, issue} = Issues.create_issue(%{"title" => "Readable by anyone"})
      {:ok, issue} = Issues.create_issue(repository(), %{"title" => "Readable by anyone"})
      {:ok, _} = Issues.create_comment(issue, %{body: "First comment"}, nil)

      {:ok, view, html} =

    end

    test "can comment on an open conversation", %{conn: conn} do
      {:ok, issue} = Issues.create_issue(%{"title" => "Needs a reply"})
      {:ok, issue} = Issues.create_issue(repository(), %{"title" => "Needs a reply"})
      {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/issues/#{issue.number}")

      view

    end

    test "cannot post to a conversation locked after the page opened", %{conn: conn} do
      {:ok, issue} = Issues.create_issue(%{"title" => "Lock this thread"})
      {:ok, issue} = Issues.create_issue(repository(), %{"title" => "Lock this thread"})
      {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/issues/#{issue.number}")
      {:ok, _locked} = Issues.update_issue(issue, %{"locked" => true})


    end

    test "get no triage controls anywhere on the issue page", %{conn: conn} do
      {:ok, issue} = Issues.create_issue(%{"title" => "Not yours to close"})
      {:ok, issue} = Issues.create_issue(repository(), %{"title" => "Not yours to close"})
      {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/issues/#{issue.number}")

      refute has_element?(view, ~s{button[phx-click="close"]})
      refute has_element?(view, ~s{button[phx-click="toggle_edit"]})
      refute has_element?(view, ~s{[id^="row-state-"]})

      assert Issues.get_issue!(issue.id).state == "open"
      assert Issues.get_issue!(repository(), issue.id).state == "open"
    end

    test "see the issue list with a filing link but no row menus", %{conn: conn} do
      {:ok, _issue} = Issues.create_issue(%{"title" => "Visible to all"})
      {:ok, _issue} = Issues.create_issue(repository(), %{"title" => "Visible to all"})

      {:ok, view, html} = live(conn, ~p"/OpenAgentsInc/openagents.com/issues")


      |> form("#issue-edit-form", issue: %{title: "Fixed title", body: "Now with steps"})
      |> render_submit()

      updated = Issues.get_issue!(issue.id)
      updated = Issues.get_issue!(repository(), issue.id)
      assert updated.title == "Fixed title"
      assert updated.body == "Now with steps"
    end

      |> element(~s{button[phx-click="close"]})
      |> render_click()

      closed = Issues.get_issue!(issue.id)
      closed = Issues.get_issue!(repository(), issue.id)
      assert closed.state == "closed"
      assert closed.state_reason == "completed"
    end
  end

  defp repository do
    OpenAgents.Repositories.get_by_path!("OpenAgentsInc", "openagents.com")
  end
end

  alias OpenAgents.Issues

  setup %{conn: conn} do
    {:ok, conn: log_in_github_user(conn, "issue-index")}
    {:ok, conn: log_in_repository_user(conn, "issue-index", repository())}
  end

  test "mounts with zeroed counts and an empty state", %{conn: conn} do

  end

  test "lists open issues with their number, author, labels, and assignees", %{conn: conn} do
    repository_user_fixture("grace-index")
    label_fixture(%{name: "bug", color: "d73a4a"})
    grace = repository_user_fixture("grace-index")
    {:ok, _membership} = OpenAgents.Repositories.add_member(repository(), grace, "contributor")
    label_fixture(repository(), %{name: "bug", color: "d73a4a"})

    {:ok, issue} =
      Issues.create_issue(%{
      Issues.create_issue(repository(), %{
        "title" => "Streaming stalls",
        "user" => %{"login" => "ada"},
        "labels" => ["bug"],

  end

  test "an issue with no author falls back to anonymous", %{conn: conn} do
    {:ok, _} = Issues.create_issue(%{"title" => "Orphaned"})
    {:ok, _} = Issues.create_issue(repository(), %{"title" => "Orphaned"})

    {:ok, _view, html} = live(conn, ~p"/OpenAgentsInc/openagents.com/issues")


  end

  test "the comment count only renders once an issue has comments", %{conn: conn} do
    {:ok, issue} = Issues.create_issue(%{"title" => "Chatty"})
    {:ok, issue} = Issues.create_issue(repository(), %{"title" => "Chatty"})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/issues")
    refute has_element?(view, ~s{svg[data-icon="comment"]})

  end

  test "patching to the closed filter swaps the stream and the current marker", %{conn: conn} do
    {:ok, _open} = Issues.create_issue(%{"title" => "Open one"})
    {:ok, closed} = Issues.create_issue(%{"title" => "Closed one"})
    {:ok, _open} = Issues.create_issue(repository(), %{"title" => "Open one"})
    {:ok, closed} = Issues.create_issue(repository(), %{"title" => "Closed one"})
    {:ok, _} = Issues.update_issue(closed, %{"state" => "closed"})

    {:ok, view, html} = live(conn, ~p"/OpenAgentsInc/openagents.com/issues")

  end

  test "the closed filter has its own empty-state wording", %{conn: conn} do
    {:ok, _open} = Issues.create_issue(%{"title" => "Open one"})
    {:ok, _open} = Issues.create_issue(repository(), %{"title" => "Open one"})

    {:ok, _view, html} = live(conn, ~p"/OpenAgentsInc/openagents.com/issues?state=closed")


  end

  test "the open and closed counts stay visible on both filters", %{conn: conn} do
    {:ok, _} = Issues.create_issue(%{"title" => "A"})
    {:ok, _} = Issues.create_issue(%{"title" => "B"})
    {:ok, c} = Issues.create_issue(%{"title" => "C"})
    {:ok, _} = Issues.create_issue(repository(), %{"title" => "A"})
    {:ok, _} = Issues.create_issue(repository(), %{"title" => "B"})
    {:ok, c} = Issues.create_issue(repository(), %{"title" => "C"})
    {:ok, _} = Issues.update_issue(c, %{"state" => "closed"})

    for state <- ["open", "closed"] do

  # and both are GitHub fields. Labels and milestone need option lists longer
  # than a row can explain, so they are edited from the issue page's rail.
  test "closing an issue from its row drops it out of the open filter", %{conn: conn} do
    {:ok, issue} = Issues.create_issue(%{"title" => "Closeable"})
    {:ok, issue} = Issues.create_issue(repository(), %{"title" => "Closeable"})
    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/issues")

    assert has_element?(view, ~s{#row-state-#{issue.id}})

    |> element(~s{#row-state-#{issue.id} button}, "Closed as not planned")
    |> render_click()

    closed = Issues.get_issue!(issue.id)
    closed = Issues.get_issue!(repository(), issue.id)
    assert closed.state == "closed"
    assert closed.state_reason == "not_planned"


  end

  test "assigning from a row keeps the row and updates the face", %{conn: conn} do
    repository_user_fixture("hopper-index")
    {:ok, issue} = Issues.create_issue(%{"title" => "Assignable"})
    hopper = repository_user_fixture("hopper-index")
    {:ok, _membership} = OpenAgents.Repositories.add_member(repository(), hopper, "contributor")
    {:ok, issue} = Issues.create_issue(repository(), %{"title" => "Assignable"})
    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/issues")

    view
    |> element(~s{#row-assignee-#{issue.id} button}, "hopper-index")
    |> render_click()

    assert Issues.get_issue!(issue.id).assignees |> Enum.map(& &1["login"]) == ["hopper-index"]
    assert Issues.get_issue!(repository(), issue.id).assignees |> Enum.map(& &1["login"]) == [
             "hopper-index"
           ]

    assert has_element?(view, ~s{#row-assignee-#{issue.id}})
    assert has_element?(view, ~s{[title="hopper-index"]})
  end

  test "the row's controls sit outside the link to the issue", %{conn: conn} do
    # A state-changing control inside a link target is how people mis-click.
    {:ok, issue} = Issues.create_issue(%{"title" => "Separate hit areas"})
    {:ok, issue} = Issues.create_issue(repository(), %{"title" => "Separate hit areas"})
    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/issues")

    title_link =

  # way reading its code is: no redirect, no controls, and an invitation to
  # sign in rather than a wall.
  test "an anonymous visitor reads a public repository's issue list" do
    {:ok, _issue} = Issues.create_issue(%{"title" => "Public spectable"})
    {:ok, _issue} = Issues.create_issue(repository(), %{"title" => "Public spectable"})

    {:ok, view, html} = live(build_conn(), ~p"/OpenAgentsInc/openagents.com/issues")


228	233		`live(build_conn(), ~p"/SecondOrg/hidden-repo/issues")`
229	234		`end`
230	235		`end`
	236	+
	237	+	`defp repository do`
	238	+	`OpenAgents.Repositories.get_by_path!("OpenAgentsInc", "openagents.com")`
	239	+	`end`
231	240		`end`

  alias OpenAgents.Issues

  setup %{conn: conn} do
    {:ok, conn: log_in_github_user(conn, "issue-new")}
    {:ok, conn: log_in_repository_user(conn, "issue-new", repository())}
  end

  test "mounts with an empty form and a cancel link back to the list", %{conn: conn} do

  end

  test "the milestone and label selects offer the seeded records", %{conn: conn} do
    milestone = milestone_fixture(%{title: "v1.0", due_on: nil})
    label_fixture(%{name: "bug", color: "d73a4a"})
    milestone = milestone_fixture(repository(), %{title: "v1.0", due_on: nil})
    label_fixture(repository(), %{name: "bug", color: "d73a4a"})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/issues/new")


      |> form("#new-issue-form", issue: %{title: "Add a runbook", body: "Please"})
      |> render_submit()

    assert [issue] = Issues.list_issues()
    assert [issue] = Issues.list_issues(repository())
    assert issue.title == "Add a runbook"
    assert issue.body == "Please"


  end

  test "a submitted label and milestone are applied to the new issue", %{conn: conn} do
    milestone = milestone_fixture(%{title: "v1.0", due_on: nil})
    label_fixture(%{name: "bug", color: "d73a4a"})
    milestone = milestone_fixture(repository(), %{title: "v1.0", due_on: nil})
    label_fixture(repository(), %{name: "bug", color: "d73a4a"})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/issues/new")


             )
             |> render_submit()

    assert [issue] = Issues.list_issues()
    assert [issue] = Issues.list_issues(repository())
    assert [%{"name" => "bug", "color" => "d73a4a"}] = issue.labels
    assert issue.milestone["title"] == "v1.0"
    assert issue.milestone["number"] == milestone.number
  end

  test "an empty label and milestone selection leaves the issue bare", %{conn: conn} do
    label_fixture(%{name: "bug", color: "d73a4a"})
    label_fixture(repository(), %{name: "bug", color: "d73a4a"})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/issues/new")


             )
             |> render_submit()

    assert [issue] = Issues.list_issues()
    assert [issue] = Issues.list_issues(repository())
    assert issue.labels == []
    assert issue.milestone == nil
  end


    assert html =~ "can&#39;t be blank"
    assert has_element?(view, "#new-issue-form")
    assert Issues.list_issues(state: "all") == []
    assert Issues.list_issues(repository(), state: "all") == []
  end

  defp repository do
    OpenAgents.Repositories.get_by_path!("OpenAgentsInc", "openagents.com")
  end
end

  alias OpenAgents.Repositories

  setup %{conn: conn} do
    {:ok, conn: log_in_github_user(conn, "issue-show")}
    {:ok, conn: log_in_repository_user(conn, "issue-show", repository())}
  end

  defp issue!(attrs) do
    {:ok, issue} = Issues.create_issue(attrs)
    {:ok, issue} = Issues.create_issue(repository(), attrs)
    issue
  end


  # an issue can never get its first label. So the group is always present and
  # states its own emptiness instead.
  test "an empty property group says so rather than disappearing", %{conn: conn} do
    repository_user_fixture("grace-show")
    grace = repository_user_fixture("grace-show")
    {:ok, _membership} = Repositories.add_member(repository(), grace, "contributor")
    bare = issue!(%{"title" => "Bare"})
    {:ok, view, html} = live(conn, path(bare))


             "the #{id} property is stated but cannot be changed"
    end

    label_fixture(%{name: "bug", color: "d73a4a"})
    milestone = milestone_fixture(%{title: "v1.0", due_on: nil})
    label_fixture(repository(), %{name: "bug", color: "d73a4a"})
    milestone = milestone_fixture(repository(), %{title: "v1.0", due_on: nil})

    rich = issue!(%{"title" => "Rich", "labels" => ["bug"], "assignees" => ["grace-show"]})
    {:ok, rich} = Issues.set_milestone(rich, milestone.number)

  end

  test "the rail changes state, labels, assignees, and the milestone", %{conn: conn} do
    repository_user_fixture("hopper-show")
    label_fixture(%{name: "bug", color: "d73a4a"})
    milestone = milestone_fixture(%{title: "v2.0", due_on: nil})
    hopper = repository_user_fixture("hopper-show")
    {:ok, _membership} = Repositories.add_member(repository(), hopper, "contributor")
    label_fixture(repository(), %{name: "bug", color: "d73a4a"})
    milestone = milestone_fixture(repository(), %{title: "v2.0", due_on: nil})
    issue = issue!(%{"title" => "Editable"})

    {:ok, view, _html} = live(conn, path(issue))

    |> element(~s{#issue-label-menu button}, "bug")
    |> render_click()

    assert Issues.get_issue!(issue.id).labels |> Enum.map(& &1["name"]) == ["bug"]
    assert Issues.get_issue!(repository(), issue.id).labels |> Enum.map(& &1["name"]) == ["bug"]

    view
    |> element(~s{#issue-assignee-menu button}, "hopper-show")
    |> render_click()

    assert Issues.get_issue!(issue.id).assignees |> Enum.map(& &1["login"]) == ["hopper-show"]
    assert Issues.get_issue!(repository(), issue.id).assignees |> Enum.map(& &1["login"]) == [
             "hopper-show"
           ]

    view
    |> element(~s{#issue-milestone-menu button}, "v2.0")
    |> render_click()

    assert Issues.get_issue!(issue.id).milestone["number"] == milestone.number
    assert Issues.get_issue!(repository(), issue.id).milestone["number"] == milestone.number

    # The rail can pick a close reason the header's two buttons cannot.
    view
    |> element(~s{#issue-state-menu button}, "Closed as not planned")
    |> render_click()

    closed = Issues.get_issue!(issue.id)
    closed = Issues.get_issue!(repository(), issue.id)
    assert closed.state == "closed"
    assert closed.state_reason == "not_planned"


    |> element(~s{#issue-label-menu button}, "bug")
    |> render_click()

    assert Issues.get_issue!(issue.id).labels == []
    assert Issues.get_issue!(repository(), issue.id).labels == []
  end

  test "a member who loses write access cannot triage through an open page", %{conn: conn} do
    user = Accounts.get_user(Plug.Conn.get_session(conn, "user_id"))
    issue = issue!(%{"title" => "Authority changed"})
    repository = Repositories.initial_repository!()
    repository = Repositories.get_by_path!("OpenAgentsInc", "openagents.com")

    {:ok, view, _html} = live(conn, path(issue))
    {:ok, _} = Repositories.add_member(repository, user, "viewer")

    html = render_click(view, "toggle_label", %{"name" => "bug"})

    assert html =~ "Only repository members can change issue labels"
    assert Issues.get_issue!(issue.id).labels == []
    assert Issues.get_issue!(repository(), issue.id).labels == []
  end

  test "the history is one feed of comments and state changes", %{conn: conn} do

    assert has_element?(view, ~s{button[phx-click="reopen"]}, "Reopen issue")
    refute has_element?(view, ~s{button[phx-click="close"]})

    closed = Issues.get_issue!(issue.id)
    closed = Issues.get_issue!(repository(), issue.id)
    assert closed.state == "closed"
    assert closed.state_reason == "completed"
    assert closed.closed_at

    assert html =~ "Issue reopened"
    assert has_element?(view, ~s{button[phx-click="close"]}, "Close issue")

    reopened = Issues.get_issue!(issue.id)
    reopened = Issues.get_issue!(repository(), issue.id)
    assert reopened.state == "open"
    assert reopened.closed_at == nil
  end

    assert html =~ "After"
    refute has_element?(view, "#issue-edit-form")

    updated = Issues.get_issue!(issue.id)
    updated = Issues.get_issue!(repository(), issue.id)
    assert updated.title == "Edited"
    assert updated.body == "After"
  end


    assert html =~ "can&#39;t be blank"
    assert has_element?(view, "#issue-edit-form")
    assert Issues.get_issue!(issue.id).title == "Editable"
    assert Issues.get_issue!(repository(), issue.id).title == "Editable"
  end

  test "adding a comment appends it to the thread and bumps the count", %{conn: conn} do

    assert html =~ "Looks good to me"
    assert html =~ "anonymous"

    assert [comment] = Issues.list_comments(issue.id)
    assert [comment] = Issues.list_comments(issue)
    assert comment.body == "Looks good to me"
    assert Issues.get_issue!(issue.id).comments == 1
    assert Issues.get_issue!(repository(), issue.id).comments == 1
  end

  test "an empty comment body is rejected and nothing is stored", %{conn: conn} do

      |> render_submit()

    assert html =~ "can&#39;t be blank"
    assert Issues.list_comments(issue.id) == []
    assert Issues.get_issue!(issue.id).comments == 0
    assert Issues.list_comments(issue) == []
    assert Issues.get_issue!(repository(), issue.id).comments == 0
  end

  test "existing comments render with their author on mount", %{conn: conn} do

342	346		`refute has_element?(view, ~s{button[phx-click="close"]})`
343	347		`refute has_element?(view, ~s{button[phx-click="toggle_edit"]})`
344	348		`end`
	349	+
	350	+	`defp repository do`
	351	+	`OpenAgents.Repositories.get_by_path!("OpenAgentsInc", "openagents.com")`
	352	+	`end`
345	353		`end`

  alias OpenAgents.Labels

  setup %{conn: conn} do
    {:ok, conn: log_in_github_user(conn, "label-index")}
    {:ok, conn: log_in_repository_user(conn, "label-index", repository())}
  end

  test "mounts with the create form and an empty state", %{conn: conn} do

  end

  test "lists seeded labels with their descriptions", %{conn: conn} do
    label_fixture(%{name: "bug", color: "d73a4a", description: "Something is broken"})
    label_fixture(%{name: "docs", color: "0075ca", description: nil})
    label_fixture(repository(), %{
      name: "bug",
      color: "d73a4a",
      description: "Something is broken"
    })

    label_fixture(repository(), %{name: "docs", color: "0075ca", description: nil})

    {:ok, view, html} = live(conn, ~p"/OpenAgentsInc/openagents.com/labels")



    assert html =~ "Label created"
    assert has_element?(view, "#labels td", "enhancement")
    assert [%Labels.Label{name: "enhancement"}] = Labels.list_labels()
    assert [%Labels.Label{name: "enhancement"}] = Labels.list_labels(repository())
  end

  test "a label missing its required color re-renders the form with an error", %{conn: conn} do


    assert html =~ "can&#39;t be blank"
    assert has_element?(view, "#new-label-form")
    assert Labels.list_labels() == []
    assert Labels.list_labels(repository()) == []
  end

  test "deleting a label removes it and returns the empty state", %{conn: conn} do
    label = label_fixture(%{name: "wontfix", color: "ffffff"})
    label = label_fixture(repository(), %{name: "wontfix", color: "ffffff"})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/labels")
    assert has_element?(view, "#labels td", "wontfix")


    assert html =~ "Label deleted"
    assert has_element?(view, ~s{[role="status"]}, "No labels yet")
    assert Labels.list_labels() == []
    assert Labels.list_labels(repository()) == []
  end

  defp repository do
    OpenAgents.Repositories.get_by_path!("OpenAgentsInc", "openagents.com")
  end
end


  defp sign_in_owner(conn, key) do
    user = repository_user_fixture(key)
    {:ok, _} = Repositories.add_member(Repositories.initial_repository!(), user, "owner")

    {:ok, _} =
      Repositories.add_member(
        Repositories.get_by_path!("OpenAgentsInc", "openagents.com"),
        user,
        "owner"
      )

    {Plug.Test.init_test_session(conn, %{"user_id" => user.id}), user}
  end

  test "an owner sees the members and their roles", %{conn: conn} do
    {conn, _owner} = sign_in_owner(conn, "members-view-owner")
    repository_user_fixture("members-view-member")
    member = repository_user_fixture("members-view-member")

    {:ok, _membership} =
      Repositories.add_member(
        Repositories.get_by_path!("OpenAgentsInc", "openagents.com"),
        member,
        "contributor"
      )

    {:ok, _view, html} = live(conn, ~p"/OpenAgentsInc/openagents.com/members")


    assert has_element?(view, "#members")
    assert html =~ "recruit"

    assert Repositories.membership_role(Repositories.initial_repository!(), recruit) ==
    assert Repositories.membership_role(
             Repositories.get_by_path!("OpenAgentsInc", "openagents.com"),
             recruit
           ) ==
             "maintainer"
  end


  test "an owner changes a member's role", %{conn: conn} do
    {conn, _owner} = sign_in_owner(conn, "members-role-owner")
    member = repository_user_fixture("role-target")
    repository = Repositories.get_by_path!("OpenAgentsInc", "openagents.com")
    {:ok, _membership} = Repositories.add_member(repository, member, "contributor")

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/members")


    })
    |> render_change()

    assert Repositories.membership_role(Repositories.initial_repository!(), member) ==
    assert Repositories.membership_role(
             Repositories.get_by_path!("OpenAgentsInc", "openagents.com"),
             member
           ) ==
             "maintainer"
  end

  test "an owner removes a member", %{conn: conn} do
    {conn, _owner} = sign_in_owner(conn, "members-remove-owner")
    member = repository_user_fixture("remove-target")
    repository = Repositories.initial_repository!()
    repository = Repositories.get_by_path!("OpenAgentsInc", "openagents.com")
    {:ok, _membership} = Repositories.add_member(repository, member, "contributor")

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/members")


  test "a demoted owner cannot keep administering through an open page", %{conn: conn} do
    {conn, owner} = sign_in_owner(conn, "members-stale-owner")
    recruit = plain_user("members-stale-recruit")
    repository = Repositories.initial_repository!()
    repository = Repositories.get_by_path!("OpenAgentsInc", "openagents.com")

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/members")
    {:ok, _} = Repositories.add_member(repository, owner, "contributor")

      |> render_click()

    assert html =~ "at least one owner"
    assert Repositories.member?(Repositories.initial_repository!(), owner)

    assert Repositories.member?(
             Repositories.get_by_path!("OpenAgentsInc", "openagents.com"),
             owner
           )
  end

  test "a non-owner is sent away", %{conn: conn} do
    conn = log_in_github_user(conn, "plain-contributor")
    user = repository_user_fixture("plain-contributor")
    repository = Repositories.get_by_path!("OpenAgentsInc", "openagents.com")
    {:ok, _membership} = Repositories.add_member(repository, user, "contributor")
    conn = Plug.Test.init_test_session(conn, %{"user_id" => user.id})

    {:error, {:redirect, %{to: to}}} = live(conn, ~p"/OpenAgentsInc/openagents.com/members")


  alias OpenAgents.Milestones

  setup %{conn: conn} do
    {:ok, conn: log_in_github_user(conn, "milestone-index")}
    {:ok, conn: log_in_repository_user(conn, "milestone-index", repository())}
  end

  test "mounts with the create form and an empty state", %{conn: conn} do

  end

  test "lists seeded milestones with their state and due date", %{conn: conn} do
    milestone_fixture(%{title: "v1.0", state: "open", due_on: "2026-12-31", description: "Ship"})
    milestone_fixture(repository(), %{
      title: "v1.0",
      state: "open",
      due_on: "2026-12-31",
      description: "Ship"
    })

    {:ok, _view, html} = live(conn, ~p"/OpenAgentsInc/openagents.com/milestones")


  end

  test "the progress meter reports the closed-to-total ratio", %{conn: conn} do
    milestone = milestone_fixture(%{title: "Beta", state: "open", due_on: nil})
    milestone = milestone_fixture(repository(), %{title: "Beta", state: "open", due_on: nil})

    {:ok, open_issue} = Issues.create_issue(%{"title" => "Still open"})
    {:ok, open_issue} = Issues.create_issue(repository(), %{"title" => "Still open"})
    {:ok, _} = Issues.set_milestone(open_issue, milestone.number)

    {:ok, done_issue} = Issues.create_issue(%{"title" => "Finished"})
    {:ok, done_issue} = Issues.create_issue(repository(), %{"title" => "Finished"})
    {:ok, done_issue} = Issues.set_milestone(done_issue, milestone.number)
    {:ok, _} = Issues.update_issue(done_issue, %{"state" => "closed"})


  end

  test "a milestone with no issues reports zero progress", %{conn: conn} do
    milestone_fixture(%{title: "Empty", due_on: nil})
    milestone_fixture(repository(), %{title: "Empty", due_on: nil})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/milestones")



    assert html =~ "Milestone created"
    assert html =~ "v2.0"
    assert [%Milestones.Milestone{title: "v2.0", number: 1}] = Milestones.list_milestones()

    assert [%Milestones.Milestone{title: "v2.0", number: 1}] =
             Milestones.list_milestones(repository())
  end

  test "a milestone with no title re-renders the form with an error", %{conn: conn} do

      |> render_submit()

    assert html =~ "can&#39;t be blank"
    assert Milestones.list_milestones() == []
    assert Milestones.list_milestones(repository()) == []
  end

  test "closing a milestone flips its state and hides the close button", %{conn: conn} do
    milestone = milestone_fixture(%{title: "Closeable", state: "open", due_on: nil})
    milestone = milestone_fixture(repository(), %{title: "Closeable", state: "open", due_on: nil})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/milestones")
    assert has_element?(view, ~s{button[phx-click="close"][phx-value-id="#{milestone.id}"]})


    assert html =~ "Milestone closed"
    refute has_element?(view, ~s{button[phx-click="close"][phx-value-id="#{milestone.id}"]})
    assert Milestones.get_milestone!(milestone.id).state == "closed"
    assert Milestones.get_milestone!(repository(), milestone.id).state == "closed"
  end

  test "deleting a milestone returns the empty state", %{conn: conn} do
    milestone = milestone_fixture(%{title: "Deletable", due_on: nil})
    milestone = milestone_fixture(repository(), %{title: "Deletable", due_on: nil})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/milestones")



    assert html =~ "Milestone deleted"
    assert has_element?(view, ~s{[role="status"]}, "No milestones yet")
    assert Milestones.list_milestones() == []
    assert Milestones.list_milestones(repository()) == []
  end

  defp repository do
    OpenAgents.Repositories.get_by_path!("OpenAgentsInc", "openagents.com")
  end
end


  setup %{conn: conn} do
    user = github_user("project-index")
    {:ok, _membership} = OpenAgents.Repositories.add_member(repository(), user, "owner")
    conn = Plug.Test.init_test_session(conn, %{"user_id" => user.id})
    {:ok, conn: conn, user: user}
  end

  end

  test "lists projects owned by the URL owner and links to each board", %{conn: conn} do
    project = project_fixture(%{title: "Roadmap", owner: "OpenAgentsInc", state: "open"})
    project =
      project_fixture(repository(), %{title: "Roadmap", owner: "OpenAgentsInc", state: "open"})

    {:ok, view, html} = live(conn, ~p"/OpenAgentsInc/openagents.com/projects")


  end

  test "the repository board lists projects regardless of their user owner", %{conn: conn} do
    project_fixture(%{title: "Someone elses", owner: "other-org"})
    project_fixture(repository(), %{title: "Someone elses", owner: "other-org"})

    {:ok, _view, html} = live(conn, ~p"/OpenAgentsInc/openagents.com/projects")


    assert html =~ "Project created"
    assert html =~ "Q3 delivery"

    assert [project] = Projects.list_projects()
    assert [project] = Projects.list_projects(repository())
    assert project.title == "Q3 delivery"
    assert project.owner == user.github_login
    assert project.state == "open"


    assert html =~ "can&#39;t be blank"
    assert has_element?(view, "#new-project-form")
    assert Projects.list_projects() == []
    assert Projects.list_projects(repository()) == []
  end

  test "deleting a project returns the empty state", %{conn: conn} do
    project = project_fixture(%{title: "Doomed", owner: "OpenAgentsInc"})
    project = project_fixture(repository(), %{title: "Doomed", owner: "OpenAgentsInc"})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/projects")



    assert html =~ "Project deleted"
    assert has_element?(view, ~s{[role="status"]}, "No projects yet")
    assert Projects.list_projects() == []
    assert Projects.list_projects(repository()) == []
  end

  test "closing a project from its row uses the state GitHub already has", %{conn: conn} do
    # Projects V2 carries `state`, so this changes a real field rather than an
    # invented one. Delete stays a separate control beside the row.
    project = project_fixture(%{title: "Closeable", owner: "OpenAgentsInc", state: "open"})
    project =
      project_fixture(repository(), %{title: "Closeable", owner: "OpenAgentsInc", state: "open"})

    {:ok, view, _html} = live(conn, ~p"/OpenAgentsInc/openagents.com/projects")

    view
    |> element(~s{#project-state-#{project.id} button}, "Closed")
    |> render_click()

    assert Projects.get_project!(project.id).state == "closed"
    assert Projects.get_project!(repository(), project.id).state == "closed"

    assert has_element?(
             view,

119	123		`"Closed"`
120	124		`)`
121	125		`end`
	126	+
	127	+	`defp repository do`
	128	+	`OpenAgents.Repositories.get_by_path!("OpenAgentsInc", "openagents.com")`
	129	+	`end`
122	130		`end`

  alias OpenAgents.Projects

  setup %{conn: conn} do
    {:ok, conn: log_in_github_user(conn, "project-show")}
    {:ok, conn: log_in_repository_user(conn, "project-show", repository())}
  end

  defp project!, do: project_fixture(%{title: "Roadmap", owner: "OpenAgentsInc"})
  defp project!, do: project_fixture(repository(), %{title: "Roadmap", owner: "OpenAgentsInc"})

  defp path(project), do: ~p"/OpenAgentsInc/openagents.com/projects/#{project.number}"



  test "the issue select offers every issue, open or closed", %{conn: conn} do
    project = project!()
    {:ok, open} = Issues.create_issue(%{"title" => "Still open"})
    {:ok, closed} = Issues.create_issue(%{"title" => "All done"})
    {:ok, open} = Issues.create_issue(repository(), %{"title" => "Still open"})
    {:ok, closed} = Issues.create_issue(repository(), %{"title" => "All done"})
    {:ok, _} = Issues.update_issue(closed, %{"state" => "closed"})

    {:ok, view, _html} = live(conn, path(project))


  test "an existing item renders as a card in its status column", %{conn: conn} do
    project = project!()
    label_fixture(%{name: "bug", color: "d73a4a"})
    {:ok, issue} = Issues.create_issue(%{"title" => "Fix the parser", "labels" => ["bug"]})
    label_fixture(repository(), %{name: "bug", color: "d73a4a"})

    {:ok, issue} =
      Issues.create_issue(repository(), %{"title" => "Fix the parser", "labels" => ["bug"]})

    {:ok, _item} =
      Projects.create_project_item(
        %{"issue_number" => issue.number, "values" => %{"Status" => "In Progress"}},
        project.id
        project
      )

    {:ok, view, html} = live(conn, path(project))


  test "an item with no recorded status falls back to To Do", %{conn: conn} do
    project = project!()
    {:ok, issue} = Issues.create_issue(%{"title" => "Unsorted"})
    {:ok, issue} = Issues.create_issue(repository(), %{"title" => "Unsorted"})

    {:ok, _item} =
      Projects.create_project_item(
        %{"issue_number" => issue.number, "values" => %{}},
        project.id
        project
      )

    {:ok, _view, html} = live(conn, path(project))


  test "submitting the form adds the issue to the board", %{conn: conn} do
    project = project!()
    {:ok, issue} = Issues.create_issue(%{"title" => "Ship the runbook"})
    {:ok, issue} = Issues.create_issue(repository(), %{"title" => "Ship the runbook"})

    {:ok, view, html} = live(conn, path(project))
    refute html =~ "Ship the runbook</a>"

             "Ship the runbook"
           )

    assert [item] = Projects.list_project_items(project.id)
    assert [item] = Projects.list_project_items(project)
    assert item.issue_id == issue.id
    assert item.values == %{"Status" => "Done"}
  end

  test "a fixture-built item lands in the column named by its Status value", %{conn: conn} do
    project = project!()
    {:ok, issue} = Issues.create_issue(%{"title" => "Fixture-placed"})
    {:ok, issue} = Issues.create_issue(repository(), %{"title" => "Fixture-placed"})

    item =
      project_item_fixture(%{
      project_item_fixture(repository(), %{
        project_id: project.id,
        issue_id: issue.id,
        values: %{"Status" => "Done"}

168	170		`live(conn, ~p"/OpenAgentsInc/openagents.com/projects/9999")`
169	171		`end`
170	172		`end`
	173	+
	174	+	`defp repository do`
	175	+	`OpenAgents.Repositories.get_by_path!("OpenAgentsInc", "openagents.com")`
	176	+	`end`
171	177		`end`

    write = route!(:post, "/api/v3/repos/:owner/:repo/issues")

    assert read.class == :public_read
    assert read.principal == "anonymous or first-party bearer token"
    assert read.scope == "forge:repository:read"
    assert read.mutation == false
    assert write.class == :authenticated_api
    assert write.principal == "first-party bearer token"

             "GET",
             "/api/v3/repos/OpenAgentsInc/openagents.com/issues",
             "stage.openagents.com"
           ).pipe_through == [:api]
           ).pipe_through == [:optional_forge_api]

    assert Phoenix.Router.route_info(
             OpenAgentsWeb.Router,

      import Plug.Conn
      import Phoenix.ConnTest
      import OpenAgentsWeb.ConnCase
      import OpenAgents.AccountsFixtures
    end
  end


        github_avatar_url: "https://avatars.githubusercontent.com/u/#{github_id}?v=4"
      })

    {:ok, _membership} = OpenAgents.Repositories.ensure_initial_membership(user)

    user
  end


    Plug.Test.init_test_session(conn, %{"user_id" => user.id})
  end

  def log_in_repository_user(conn, key, repository) when is_binary(key) do
    user = github_user(key)
    {:ok, _membership} = OpenAgents.Repositories.add_member(repository, user, "owner")
    Plug.Test.init_test_session(conn, %{"user_id" => user.id})
  end

  @doc """
  Logs in an account that has already written to the agent.


    put_forge_api_token_for_user(conn, user)
  end

  def put_forge_api_token(conn, key, %OpenAgents.Repositories.Repository{} = repository)
      when is_binary(key) do
    user = github_user("api-token-" <> key)
    {:ok, _membership} = OpenAgents.Repositories.add_member(repository, user, "owner")
    put_forge_api_token_for_user(conn, user)
  end

  def put_forge_api_token(conn, key, login)
      when is_binary(key) and is_binary(login) do
    user = github_user("api-token-" <> key, login)

    put_forge_api_token_for_user(conn, user)
  end

  def put_forge_api_token(conn, key, login, %OpenAgents.Repositories.Repository{} = repository)
      when is_binary(key) and is_binary(login) do
    user = github_user("api-token-" <> key, login)
    {:ok, _membership} = OpenAgents.Repositories.add_member(repository, user, "owner")
    put_forge_api_token_for_user(conn, user)
  end

  defp put_forge_api_token_for_user(conn, user) do
    {:ok, _credential, plaintext} =
      OpenAgents.ApiTokens.create(user, %{

      import Ecto.Changeset
      import Ecto.Query
      import OpenAgents.DataCase
      import OpenAgents.AccountsFixtures
    end
  end


        github_avatar_url: "https://avatars.githubusercontent.com/u/#{github_id}?v=4"
      })

    {:ok, _membership} = OpenAgents.Repositories.ensure_initial_membership(user)
    user
  end

  def repository_fixture(attrs \\ %{}) do
    suffix = System.unique_integer([:positive, :monotonic])

    defaults = %{
      owner: "TestOrg#{suffix}",
      name: "test-repository-#{suffix}",
      visibility: "public",
      default_branch: "main"
    }

    {:ok, repository} =
      defaults
      |> Map.merge(Map.new(attrs))
      |> OpenAgents.Repositories.create_repository()

    repository
  end

  def repository_with_member_fixture(user, attrs \\ %{}, role \\ "owner") do
    repository = repository_fixture(attrs)
    {:ok, _membership} = OpenAgents.Repositories.add_member(repository, user, role)
    repository
  end
end

  The issue number is assigned by the context, so callers get a fresh,
  monotonically increasing number without having to coordinate.
  """
  def issue_fixture(attrs \\ %{}) do
  def issue_fixture(repository, attrs \\ %{}) do
    {:ok, issue} =
      attrs
      |> Enum.into(%{title: "some title"})
      |> OpenAgents.Issues.create_issue()
      OpenAgents.Issues.create_issue(repository, Enum.into(attrs, %{title: "some title"}))

    issue
  end

  @doc """
  Generate a label.
  """
  def label_fixture(attrs \\ %{}) do
  def label_fixture(repository, attrs \\ %{}) do
    {:ok, label} =
      attrs
      |> Enum.into(%{
        color: "some color",
        description: "some description",
        name: "some name"
      })
      |> OpenAgents.Labels.create_label()
      OpenAgents.Labels.create_label(
        repository,
        Enum.into(attrs, %{
          color: "some color",
          description: "some description",
          name: "some name"
        })
      )

    label
  end

  @doc """
  Generate a milestone.
  """
  def milestone_fixture(attrs \\ %{}) do
  def milestone_fixture(repository, attrs \\ %{}) do
    {:ok, milestone} =
      attrs
      |> Enum.into(%{
        description: "some description",
        due_on: "some due_on",
        number: 42,
        state: "some state",
        title: "some title"
      })
      |> OpenAgents.Milestones.create_milestone()
      OpenAgents.Milestones.create_milestone(
        repository,
        Enum.into(attrs, %{
          description: "some description",
          due_on: "some due_on",
          number: 42,
          state: "some state",
          title: "some title"
        })
      )

    milestone
  end

  @doc """
  Generate a project_field.
  """
  def project_field_fixture(attrs \\ %{}) do
    {:ok, project} =
      OpenAgents.Projects.create_project(%{title: "Fixture project", owner: "OpenAgents"})
  def project_field_fixture(repository, attrs \\ %{}) do
    normalized = Map.new(attrs)
    project_id = Map.get(normalized, :project_id) || Map.get(normalized, "project_id")

    project =
      if project_id do
        OpenAgents.Projects.get_project!(repository, project_id)
      else
        {:ok, project} =
          OpenAgents.Projects.create_project(repository, %{
            title: "Fixture project",
            owner: "OpenAgents"
          })

        project
      end

    {:ok, project_field} =
      attrs

  @doc """
  Generate a project_item.
  """
  def project_item_fixture(attrs \\ %{}) do
    {:ok, project} =
      OpenAgents.Projects.create_project(%{title: "Fixture project", owner: "OpenAgents"})
  def project_item_fixture(repository, attrs \\ %{}) do
    normalized = Map.new(attrs)
    project_id = Map.get(normalized, :project_id) || Map.get(normalized, "project_id")
    issue_id = Map.get(normalized, :issue_id) || Map.get(normalized, "issue_id")

    {:ok, issue} = OpenAgents.Issues.create_issue(%{title: "Fixture issue"})
    project =
      if project_id do
        OpenAgents.Projects.get_project!(repository, project_id)
      else
        {:ok, project} =
          OpenAgents.Projects.create_project(repository, %{
            title: "Fixture project",
            owner: "OpenAgents"
          })

        project
      end

    issue =
      if issue_id do
        OpenAgents.Issues.get_issue!(repository, issue_id)
      else
        {:ok, issue} = OpenAgents.Issues.create_issue(repository, %{title: "Fixture issue"})
        issue
      end

    {:ok, project_item} =
      attrs

        project_id: project.id,
        issue_id: issue.id
      })
      |> OpenAgents.ProjectItems.create_project_item()
      |> then(&OpenAgents.ProjectItems.create_project_item(repository, &1))

    project_item
  end

  @doc """
  Generate a project.
  """
  def project_fixture(attrs \\ %{}) do
  def project_fixture(repository, attrs \\ %{}) do
    {:ok, project} =
      attrs
      |> Enum.into(%{
        owner: "some owner",
        state: "some state",
        title: "some title"
      })
      |> OpenAgents.Projects.create_project()
      OpenAgents.Projects.create_project(
        repository,
        Enum.into(attrs, %{
          owner: "some owner",
          state: "some state",
          title: "some title"
        })
      )

    project
  end

1884	1884		`list_visible_repositories/1` held had already lost the `ready` half and
1885	1885		`disagreed with the paged read about the same repository; there is one copy now.`
1886	1886
	1887	+	`Amended 2026-08-22 (explicit issue and project repository scope): production`
	1888	+	`contexts accept a repository or a resource that already carries its repository`
	1889	+	`identity. No context function selects a default repository or grants membership`
	1890	+	`as a side effect. The Projects V2 API uses`
	1891	+	`/api/v3/repos/:owner/:repo/projectsV2`; every project, item, and field query
	1892	+	`includes that repository. Optional bearer authentication lets a member read a`
	1893	+	`private repository's issues and projects, while anonymous readers and`
	1894	+	nonmembers receive `404 Not Found`. Every write still requires `forge:write`
	1895	+	`and a writable membership in the same repository.`
	1896	+
1887	1897		Evidence: `OpenAgents.Repositories`, `OpenAgents.Repositories.Provisioner`,
1888	1898		`OpenAgents.Repositories.Importer`, `OpenAgents.Forge.GitHTTP`,
1889	1899		`test/openagents/repository_lifecycle_test.exs`,
1890	1900		`test/openagents/repositories/provisioner_test.exs`,
1891	1901		`test/openagents_web/controllers/repository_controller_test.exs`,
	1902	+	`test/openagents_web/controllers/issue_controller_test.exs`,
	1903	+	`test/openagents_web/controllers/project_controller_test.exs`,
1892	1904		`test/openagents/issues_workspace_test.exs`,
1893	1905		`test/openagents_web/live/issue_workspace_live_test.exs`,
1894	1906		`test/openagents_web/live/project_workspace_live_test.exs`, and

382	388
383	389		`### Stage 7 — Make projects addressable, then build project commands (this repository, then CLI; large)`
384	390
	391	+	`Shipped on 2026-08-22. Projects now use repository-shaped routes and no`
	392	+	production context selects a default repository. The generic `openagents api`
	393	+	`command can address the resulting project surface; dedicated project commands`
	394	+	`remain future CLI work.`
	395	+
385	396		Unpin the project surface from `Repositories.initial_repository!()` (`projects.ex:26`, `:131`), make `ProjectController.create` honor its own `:owner` segment instead of resolving `Repositories.initial_path()` (`project_controller.ex:21`), reconcile `POST /api/v3/:owner/projectsV2` with the `/users/:username/projectsV2` shape every other project route uses (`router.ex:290`), and give the project reads a visibility predicate. Only then are there project commands worth writing. Size: large, and it is genuinely a redesign rather than a port.
386	397
387	398		`### What makes issue management usable this week versus complete`

211	211		1. The coverage floor gates nothing. `mix.exs` declares `threshold: 83.0`, and `ops/ci/coverage.sh` correctly unions default and cluster-only passes, but neither `mix precommit` nor `gate.sh` invokes the script. Add a coverage stage to the gate.
212	212		`2. No hosted CI. Verification depends entirely on developers running the pre-push hook locally; nothing remote proves a push passed the gate. This is documented as deliberate, and the receipt system makes external attestation easy to add later — but today the guarantee is trust-based.`
213	213		3. Contexts without same-name tests. Verified list includes `Audit`, `Mailer`, `BuildInfo`, `ComputerAgentJobs`, `ReleaseState`, `TurnRecovery` (covered indirectly), among others. `Audit` appears in only one indirect test; `Mailer` has zero test references.
214		-	4. A known cross-user authorization gap is pinned as expected behavior. Per the coverage audit, `ProjectController` ignores the `:username` segment, so a project owned by alice is readable and writable at `/users/bob/projectsV2/:n`. Tests deliberately document the divergence instead of fixing it. Decide: either implement username scoping or remove the segment from the contract.
	214	+	4. Resolved on 2026-08-22: project routes previously ignored username authority. Projects now use `/repos/:owner/:repo/projectsV2`, and the repository path controls read and write authority for every project, item, and field operation.
215	215		5. Test-rule violations. Seven bare `Process.sleep/1` call sites contradict the repository's own testing rules (`coding_job_test.exs:118`, `computer_tools_test.exs:43`, `registry_and_runner_test.exs:39`, `builder_test.exs:266`, `ra_cluster_test.exs:160` and neighbors). Replace with monitors or the shared `eventually` helper.
216	216		6. Async tagging is inconsistent: 76 files tagged `async: true`, 109 tagged false, 48 untagged. Some serialization is likely habitual rather than required; audit and tag deliberately.
217	217

213	213
214	214		```sh
215	215		`REPOSITORY_API=https://openagents.com/api/v3/repos/OpenAgentsInc/openagents.com`
216		-	`USER_LOGIN=$(curl -fsS "https://openagents.com/api/v3/user" \`
217		-	`-H "Authorization: Bearer $TOKEN" \| jq -r '.login')`
218	216
219	217		`curl -fsS -X POST "$REPOSITORY_API/milestones" \`
220	218		`-H "Authorization: Bearer $TOKEN" \`

222	220		`-d '{"title": "Backlog hygiene", "description": "First triage sweep"}'`
223	221
224	222		`PROJECT_NUMBER=$(curl -fsS -X POST \`
225		-	`"https://openagents.com/api/v3/$USER_LOGIN/projectsV2" \`
	223	+	`"$REPOSITORY_API/projectsV2" \`
226	224		`-H "Authorization: Bearer $TOKEN" \`
227	225		`-H "Content-Type: application/json" \`
228	226		`-d '{"title": "openagents.com roadmap"}' \| jq -r '.number')`
229	227
230	228		`curl -fsS -X POST \`
231		-	`"https://openagents.com/api/v3/users/$USER_LOGIN/projectsV2/$PROJECT_NUMBER/fields" \`
	229	+	`"$REPOSITORY_API/projectsV2/$PROJECT_NUMBER/fields" \`
232	230		`-H "Authorization: Bearer $TOKEN" \`
233	231		`-H "Content-Type: application/json" \`
234	232		`-d '{"name": "Status", "data_type": "single_select", "options": {"values": ["To Do", "In Progress", "Done"]}}'`
235	233		```
236	234
237		-	`The project belongs to the GitHub login tied to your token. Add high-signal`
	235	+	The project belongs to the repository in `REPOSITORY_API`. Add high-signal
238	236		issues to the board and set their `Status` value through the project items API.
239	237
240	238		`### Label vocabulary`

Commit

Remove implicit repository routing

Deploy story

Not deployed through the forge lane

Changed files

Diff

2	2
3	3		`Date: 2026-08-21`
4	4		Commits measured: `81e4c25eb5b5` (`openagents/main`, the forge) for the API; `5bd0061e4f6e` in the `openagents` monorepo for `packages/openagents-cli` (package version `0.1.7`)
5		-	Status: Stage 1 shipped on 2026-08-21 as `@openagentsinc/cli@0.2.1`; see section 5. Everything else below describes the surface as measured, unchanged.
	5	+	Status: Stages 1, 2, and 7 shipped. Stage 1 added `openagents api` in `@openagentsinc/cli@0.2.1`. Stages 2 and 7 added optional-bearer issue reads and repository-scoped Projects V2 routes on 2026-08-22. Historical measurements below retain the original findings.
6	6		`Question: Does the CLI only cover repository upload? What of the Issues and Projects API does it reach? Should that coverage be generated from an OpenAPI document instead of hand-written? What is the fastest honest path to managing issues and projects from a terminal?`
7	7		Method: direct reading of `lib/openagents_web/router.ex`, every controller it routes to under `/api/v3`, the contexts behind them (`lib/openagents/issues.ex`, `labels.ex`, `milestones.ex`, `projects.ex`, `repositories.ex`), the auth plugs, `lib/openagents_web/route_authority.ex`, `priv/api-contracts/repositories-v1.json` and its controller and test, and `docs/openagents-cli/`; plus direct reading of all 21 source files in the `openagents` monorepo at `packages/openagents-cli/src/` and its tests. The CLI lives in a different repository, so every CLI citation names it. Claims that neither repository can settle are in section 7 with the command that would settle them.
8	8

10	10
11	11		`## 0. Summary`
12	12
	13	+	`> Update, 2026-08-22: The server now resolves Projects V2 through`
	14	+	> `/repos/:owner/:repo/projectsV2`, applies the named repository's read and
	15	+	`> write policy to every project operation, and supports authenticated reads of`
	16	+	> private issues. The `initial_repository!/0` and `initial_path/0` shortcuts no
	17	+	`> longer exist. The findings below describe the pre-remediation surface.`
	18	+
13	19		`The owner is right. The CLI is repository-shaped and reaches none of the Issues and Projects API.`
14	20
15	21		The numbers are clean. The router exposes 50 routes under `/api/v3` (`lib/openagents_web/router.ex:229`, `:253`, `:259`). The CLI calls 11 of them — the authenticated user, repository create, list, view, delete, the two import routes, import status, and the two device-authorization routes. Those 11 are exactly the routes named in the hand-written contract document at `priv/api-contracts/repositories-v1.json:18`. The other 39 routes — every issue, comment, label, milestone, assignee, and project endpoint — have no CLI surface at all, and the CLI's own documentation says so: `docs/openagents-cli/command-reference.md:3` scopes the tool to "authentication and hosted repositories", and `:171` lists a generic API command among the things the release does not provide.

32	32
33	33		`\| Method \| Path \|`
34	34		`\| --- \| --- \|`
35		-	\| `GET` \| `/users/{username}/projectsV2` \|
36		-	\| `POST` \| `/{owner}/projectsV2` \|
37		-	\| `GET` \| `/users/{username}/projectsV2/{project_number}` \|
38		-	\| `GET, POST` \| `/users/{username}/projectsV2/{project_number}/items` \|
39		-	\| `PATCH` \| `/users/{username}/projectsV2/{project_number}/items/{item_id}` \|
40		-	\| `GET` \| `/users/{username}/projectsV2/{project_number}/fields` \|
	35	+	\| `GET, POST` \| `/repos/{owner}/{repo}/projectsV2` \|
	36	+	\| `GET` \| `/repos/{owner}/{repo}/projectsV2/{project_number}` \|
	37	+	\| `GET, POST` \| `/repos/{owner}/{repo}/projectsV2/{project_number}/items` \|
	38	+	\| `PATCH` \| `/repos/{owner}/{repo}/projectsV2/{project_number}/items/{item_id}` \|
	39	+	\| `GET, POST` \| `/repos/{owner}/{repo}/projectsV2/{project_number}/fields` \|
41	40
42	41		`The project-creation endpoint is an OpenAgents extension because the comparable`
43	42		`GitHub Projects V2 creation workflow is not supplied by the assessed REST`

48	47
49	48		`These are current measured behaviors:`
50	49
51		-	- `/api/v3` public reads and authenticated writes use separate pipelines.
	50	+	- `/api/v3` anonymous and optional-bearer reads and authenticated writes use
	51	+	`separate pipelines.`
52	52		Writes require an expiring digest-only `oa_pat_…` bearer with exact
53	53		`forge:write` scope. An authenticated person creates and revokes credentials
54	54		at `/settings/api-tokens`; plaintext is shown once.

60	60		`assignee links, milestones, and project items.`
61	61		`- Issue and milestone numbers are repository-local. Project numbers are also`
62	62		`repository-local for the repository-shaped LiveView surface.`
63		-	`- Project show, item, update-item, and field actions enforce the username in the`
64		-	`route. The user-shaped Projects V2 subset is limited to the explicit initial`
65		-	`repository because those compatibility URLs contain no repository segment.`
	63	+	`- Project list, show, item, update-item, and field actions resolve the repository`
	64	+	`from the route. Public repositories allow anonymous reads. Private reads and`
	65	+	`every write require membership in that repository.`
66	66		`- Assignee reads return active repository members with writable roles, and`
67	67		`issue assignment accepts only those members.`
68	68

20	20		`@doc "How many issues one index page shows."`
21	21		`def per_page, do: @issues_per_page`
22	22
23		-	`def list_issues(opts \\ []) when is_list(opts),`
24		-	`do: list_issues(Repositories.initial_repository!(), opts)`
25		-
26		-	`def list_issues(%Repository{id: repository_id}, opts) when is_list(opts) do`
	23	+	`def list_issues(%Repository{id: repository_id}, opts \\ []) when is_list(opts) do`
27	24		`repository_id`
28	25		`\|> issue_query(opts)`
29	26		`\|> order_by([issue], desc: issue.inserted_at, desc: issue.id)`

136	133		`\|> maybe_filter_search(Keyword.get(opts, :q))`
137	134		`end`
138	135
139		-	`def get_issue!(id), do: get_issue!(Repositories.initial_repository!(), id)`
140		-
141	136		`def get_issue!(%Repository{id: repository_id}, id) do`
142	137		`Repo.get_by!(Issue, id: id, repository_id: repository_id)`
143	138		`end`
144	139
145		-	`def get_issue_by_number!(number) when is_integer(number),`
146		-	`do: get_issue_by_number!(Repositories.initial_repository!(), number)`
147		-
148	140		`def get_issue_by_number!(%Repository{id: repository_id}, number) when is_integer(number),`
149	141		`do: Repo.get_by!(Issue, repository_id: repository_id, number: number)`
150	142

160	152		`)`
161	153		`end`
162	154
163		-	`def create_issue(attrs \\ %{}),`
164		-	`do: create_issue(Repositories.initial_repository!(), attrs, nil)`
165		-
166	155		`def create_issue(%Repository{} = repository, attrs),`
167	156		`do: create_issue(repository, attrs, nil)`
168	157

257	246		`end`
258	247		`end`
259	248
260		-	`def change_issue(%Issue{} = issue, attrs \\ %{}) do`
261		-	`attrs =`
262		-	`if is_nil(issue.repository_id) do`
263		-	`attrs`
264		-	`\|> to_string_map()`
265		-	`\|> Map.put("repository_id", Repositories.initial_repository!().id)`
266		-	`else`
267		-	`attrs`
268		-	`end`
	249	+	`def change_issue(%Repository{id: repository_id}, %Issue{} = issue, attrs) do`
	250	+	`attrs = attrs \|> to_string_map() \|> Map.put("repository_id", repository_id)`
	251	+	`Issue.changeset(issue, attrs)`
	252	+	`end`
269	253
	254	+	`def change_issue(%Issue{repository_id: repository_id} = issue, attrs \\ %{})`
	255	+	`when not is_nil(repository_id) do`
270	256		`Issue.changeset(issue, attrs)`
271	257		`end`
272	258

339	325		`\|> Repo.all()`
340	326		`end`
341	327
342		-	`def list_comments(issue_id) do`
343		-	`issue = get_issue!(issue_id)`
344		-	`list_comments(issue)`
345		-	`end`
346		-
347		-	`def get_comment!(id), do: get_comment!(Repositories.initial_repository!(), id)`
348		-
349	328		`def get_comment!(%Repository{id: repository_id}, id) do`
350	329		`Repo.get_by!(Comment, id: id, repository_id: repository_id)`
351	330		`end`

7	7		`alias OpenAgents.Accounts.User`
8	8		`alias OpenAgents.Analytics`
9	9		`alias OpenAgents.Repo`
10		-	`alias OpenAgents.Repositories`
11	10		`alias OpenAgents.Repositories.Repository`
12	11
13	12		`alias OpenAgents.Labels.Label`

8	8		`alias OpenAgents.Analytics`
9	9		`alias OpenAgents.Issues.Issue`
10	10		`alias OpenAgents.Repo`
11		-	`alias OpenAgents.Repositories`
12	11		`alias OpenAgents.Repositories.Repository`
13	12
14	13		`alias OpenAgents.Milestones.Milestone`

8	8
9	9		`alias OpenAgents.ProjectItems.ProjectItem`
10	10		`alias OpenAgents.Projects.Project`
11		-	`alias OpenAgents.Repositories`
	11	+	`alias OpenAgents.Repositories.Repository`
12	12
13	13		`@doc """`
14	14		`Returns the list of project_items.`

19	19		`RepositoryImport`
20	20		`}`
21	21
22		-	`@initial_owner "OpenAgentsInc"`
23		-	`@initial_name "openagents.com"`
24	22		`@writable_roles ~w(owner maintainer contributor)`
25	23		`@all_roles ~w(owner maintainer contributor viewer)`
26	24		`@repository_namespace_limit 100`

362	341		`)`
363	342		`end`
364	343
365		-	`def create_comment(attrs \\ %{}) do`
	344	+	`def create_comment(attrs) when is_map(attrs) do`
366	345		`normalized = to_string_map(attrs)`
367	346
368	347		`case Map.fetch(normalized, "issue_id") do`
369	348		`{:ok, issue_id} ->`
370		-	`issue = get_issue!(issue_id)`
371		-	`create_comment(issue, normalized, nil)`
	349	+	`case Repo.get(Issue, issue_id) do`
	350	+	`%Issue{} = issue -> create_comment(issue, normalized, nil)`
	351	+	`nil -> invalid_comment(normalized)`
	352	+	`end`
372	353
373	354		`:error ->`
374		-	`now = DateTime.utc_now() \|> DateTime.truncate(:second)`
375		-
376		-	`%Comment{}`
377		-	`\|> Comment.changeset(`
378		-	`normalized`
379		-	`\|> Map.put("repository_id", Repositories.initial_repository!().id)`
380		-	`\|> Map.put_new("created_at", now)`
381		-	`\|> Map.put_new("updated_at", now)`
382		-	`)`
383		-	`\|> Ecto.Changeset.apply_action(:insert)`
	355	+	`invalid_comment(normalized)`
384	356		`end`
385	357		`end`
386	358
	359	+	`defp invalid_comment(attrs) do`
	360	+	`now = DateTime.utc_now() \|> DateTime.truncate(:second)`
	361	+
	362	+	`%Comment{}`
	363	+	`\|> Comment.changeset(`
	364	+	`attrs`
	365	+	`\|> Map.put_new("created_at", now)`
	366	+	`\|> Map.put_new("updated_at", now)`
	367	+	`)`
	368	+	`\|> Ecto.Changeset.apply_action(:insert)`
	369	+	`end`
	370	+
387	371		`def create_comment(%Issue{} = issue, attrs, author \\ nil)`
388	372		`when is_nil(author) or is_struct(author, User) do`
389	373		`normalized =`

21	20		`[%Label{}, ...]`
22	21
23	22		`"""`
24		-	`def list_labels, do: list_labels(Repositories.initial_repository!())`
25		-
26	23		`def list_labels(%Repository{id: repository_id}) do`
27	24		`Label`
28	25		`\|> where(repository_id: ^repository_id)`

44	41		`** (Ecto.NoResultsError)`
45	42
46	43		`"""`
47		-	`def get_label!(id), do: get_label!(Repositories.initial_repository!(), id)`
48		-
49	44		`def get_label!(%Repository{id: repository_id}, id) do`
50	45		`Repo.get_by!(Label, id: id, repository_id: repository_id)`
51	46		`end`
52	47
53		-	`def get_label_by_name!(name) when is_binary(name) do`
54		-	`get_label_by_name!(Repositories.initial_repository!(), name)`
55		-	`end`
56		-
57	48		`def get_label_by_name!(%Repository{id: repository_id}, name) when is_binary(name) do`
58	49		`Repo.get_by!(Label, repository_id: repository_id, name: URI.decode(name))`
59	50		`end`

114	105		`{:error, %Ecto.Changeset{}}`
115	106
116	107		`"""`
117		-	`def create_label(attrs), do: create_label(Repositories.initial_repository!(), attrs, nil)`
118		-
119	108		`def create_label(%Repository{} = repository, attrs, actor \\ nil)`
120	109		`when is_nil(actor) or is_struct(actor, User) do`
121	110		`attrs =`

22	21		`[%Milestone{}, ...]`
23	22
24	23		`"""`
25		-	`def list_milestones, do: list_milestones(Repositories.initial_repository!())`
26		-
27	24		`def list_milestones(%Repository{id: repository_id}) do`
28	25		`Milestone`
29	26		`\|> where(repository_id: ^repository_id)`

46	43		`** (Ecto.NoResultsError)`
47	44
48	45		`"""`
49		-	`def get_milestone!(id), do: get_milestone!(Repositories.initial_repository!(), id)`
50		-
51	46		`def get_milestone!(%Repository{id: repository_id}, id) do`
52	47		`Milestone`
53	48		`\|> where(id: ^id, repository_id: ^repository_id)`

55	50		`\|> Repo.one!()`
56	51		`end`
57	52
58		-	`def get_milestone_by_number!(number) when is_integer(number),`
59		-	`do: get_milestone_by_number!(Repositories.initial_repository!(), number)`
60		-
61	53		`def get_milestone_by_number!(%Repository{id: repository_id}, number) when is_integer(number) do`
62	54		`Milestone`
63	55		`\|> where(repository_id: ^repository_id, number: ^number)`

92	84		`{:error, %Ecto.Changeset{}}`
93	85
94	86		`"""`
95		-	`def create_milestone(attrs \\ %{}),`
96		-	`do: create_milestone(Repositories.initial_repository!(), attrs, nil)`
97		-
98	87		`def create_milestone(%Repository{} = repository, attrs, actor \\ nil)`
99	88		`when is_nil(actor) or is_struct(actor, User) do`
100	89		`normalized = for {k, v} <- attrs, into: %{}, do: {to_string(k), v}`

19	19		`[%ProjectItem{}, ...]`
20	20
21	21		`"""`
22		-	`def list_project_items do`
23		-	`repository_id = Repositories.initial_repository!().id`
	22	+	`def list_project_items(%Repository{id: repository_id}) do`
24	23		`Repo.all(from item in ProjectItem, where: item.repository_id == ^repository_id)`
25	24		`end`
26	25

38	37		`** (Ecto.NoResultsError)`
39	38
40	39		`"""`
41		-	`def get_project_item!(id) do`
42		-	`repository_id = Repositories.initial_repository!().id`
	40	+	`def get_project_item!(%Repository{id: repository_id}, id) do`
43	41		`Repo.get_by!(ProjectItem, id: id, repository_id: repository_id)`
44	42		`end`
45	43

55	53		`{:error, %Ecto.Changeset{}}`
56	54
57	55		`"""`
58		-	`def create_project_item(attrs) do`
	56	+	`def create_project_item(%Repository{} = repository, attrs) do`
59	57		`attrs = for {key, value} <- attrs, into: %{}, do: {to_string(key), value}`
60		-	`repository_id = repository_id_for(Map.get(attrs, "project_id"))`
	58	+	`repository_id = repository_id_for(repository, Map.get(attrs, "project_id"))`
61	59
62	60		`%ProjectItem{}`
63	61		`\|> ProjectItem.changeset(Map.put(attrs, "repository_id", repository_id))`

111	109		`ProjectItem.changeset(project_item, attrs)`
112	110		`end`
113	111
114		-	`defp repository_id_for(nil), do: Repositories.initial_repository!().id`
	112	+	`defp repository_id_for(%Repository{id: repository_id}, nil), do: repository_id`
115	113
116		-	`defp repository_id_for(project_id) do`
117		-	`case Repo.get(Project, project_id) do`
	114	+	`defp repository_id_for(%Repository{id: repository_id}, project_id) do`
	115	+	`case Repo.get_by(Project, id: project_id, repository_id: repository_id) do`
118	116		`%Project{repository_id: repository_id} -> repository_id`
119		-	`nil -> Repositories.initial_repository!().id`
	117	+	`nil -> repository_id`
120	118		`end`
121	119		`end`
122	120		`end`

13	13		`alias OpenAgents.Repositories`
14	14		`alias OpenAgents.Repositories.Repository`
15	15
16		-	`def list_projects, do: list_projects(Repositories.initial_repository!())`
17		-
18	16		`def list_projects(%Repository{id: repository_id}) do`
19	17		`Project`
20	18		`\|> where(repository_id: ^repository_id)`

22	20		`\|> Repo.all()`
23	21		`end`
24	22
25		-	`def list_projects_by_owner(username) when is_binary(username) do`
26		-	`repository_id = Repositories.initial_repository!().id`
27		-
28		-	`Repo.all(`
29		-	`from project in Project,`
30		-	`where:`
31		-	`project.repository_id == ^repository_id and`
32		-	`fragment("lower(?)", project.owner) == ^String.downcase(username),`
33		-	`order_by: [asc: project.number]`
34		-	`)`
35		-	`end`
36		-
37	23		`@projects_per_page 25`
38	24
39	25		`@doc "How many projects one workspace-wide page shows."`

103	89		`)`
104	90		`end`
105	91
106		-	`def get_project!(id), do: get_project!(Repositories.initial_repository!(), id)`
107		-
108	92		`def get_project!(%Repository{id: repository_id}, id) do`
109	93		`Repo.get_by!(Project, id: id, repository_id: repository_id)`
110	94		`end`
111	95
112		-	`def get_project_by_number!(number) when is_integer(number),`
113		-	`do: get_project_by_number!(Repositories.initial_repository!(), number)`
114		-
115	96		`def get_project_by_number!(%Repository{id: repository_id}, number) when is_integer(number),`
116	97		`do: Repo.get_by!(Project, repository_id: repository_id, number: number)`
117	98

127	108		`)`
128	109		`end`
129	110
130		-	`def get_project_by_owner_and_number!(username, number) when is_integer(number) do`
131		-	`repository_id = Repositories.initial_repository!().id`
132		-
133		-	`Repo.one!(`
134		-	`from project in Project,`
135		-	`where:`
136		-	`project.repository_id == ^repository_id and`
137		-	`fragment("lower(?)", project.owner) == ^String.downcase(username) and`
138		-	`project.number == ^number`
139		-	`)`
140		-	`end`
141		-
142		-	`def create_project(attrs \\ %{}),`
143		-	`do: create_project(Repositories.initial_repository!(), attrs, nil)`
144		-
145	111		`def create_project(%Repository{} = repository, attrs),`
146	112		`do: create_project(repository, attrs, nil)`
147	113

219	185
220	186		`def delete_project(%Project{} = project), do: Repo.delete(project)`
221	187
222		-	`def change_project(%Project{} = project, attrs \\ %{}) do`
223		-	`attrs =`
224		-	`if is_nil(project.repository_id) do`
225		-	`attrs`
226		-	`\|> to_string_map()`
227		-	`\|> Map.put("repository_id", Repositories.initial_repository!().id)`
228		-	`else`
229		-	`attrs`
230		-	`end`
231		-
	188	+	`def change_project(%Repository{id: repository_id}, %Project{} = project, attrs) do`
	189	+	`attrs = attrs \|> to_string_map() \|> Map.put("repository_id", repository_id)`
232	190		`Project.changeset(project, attrs)`
233	191		`end`
234	192
235		-	`def list_project_items(project_id) when is_integer(project_id) do`
236		-	`project = get_project!(project_id)`
237		-	`list_project_items(project)`
	193	+	`def change_project(%Project{repository_id: repository_id} = project, attrs \\ %{})`
	194	+	`when not is_nil(repository_id) do`
	195	+	`Project.changeset(project, attrs)`
238	196		`end`
239	197
240	198		`def list_project_items(%Project{id: project_id, repository_id: repository_id}) do`

257	210		`)`
258	211		`end`
259	212
260		-	`def get_project_item_by_owner!(username, project_number, item_id) do`
261		-	`repository_id = Repositories.initial_repository!().id`
262		-
263		-	`Repo.one!(`
264		-	`from item in ProjectItem,`
265		-	`join: project in Project,`
266		-	`on:`
267		-	`project.id == item.project_id and project.repository_id == item.repository_id and`
268		-	`project.number == ^project_number,`
269		-	`where:`
270		-	`item.repository_id == ^repository_id and item.id == ^item_id and`
271		-	`fragment("lower(?)", project.owner) == ^String.downcase(username)`
272		-	`)`
273		-	`end`
274		-
275	213		`def create_project_item(attrs, project, actor \\ nil)`
276	214
277		-	`def create_project_item(attrs, project_id, actor)`
278		-	`when is_integer(project_id) do`
279		-	`project = get_project!(project_id)`
280		-	`create_project_item(attrs, project, actor)`
281		-	`end`
282		-
283	215		`def create_project_item(attrs, %Project{} = project, actor)`
284	216		`when is_nil(actor) or is_struct(actor, User) do`
285	217		`attrs = to_string_map(attrs)`

336	268		`\|> Repo.update()`
337	269		`end`
338	270
339		-	`def list_project_fields(project_id) when is_integer(project_id) do`
340		-	`project = get_project!(project_id)`
341		-	`list_project_fields(project)`
342		-	`end`
343		-
344	271		`def list_project_fields(%Project{id: project_id}) do`
345	272		`ProjectField`
346	273		`\|> where(project_id: ^project_id)`

46	44		`# progress or provenance.`
47	45		`@provisioning_assocs [:repository_import, :provisioning_outbox]`
48	46
49		-	`def initial_path, do: {@initial_owner, @initial_name}`
50		-
51		-	`def initial_repository! do`
52		-	`get_by_path!(@initial_owner, @initial_name)`
53		-	`end`
54		-
55	47		`def get_by_path!(owner, name) when is_binary(owner) and is_binary(name) do`
56	48		`owner_key = String.downcase(owner)`
57	49		`name_key = String.downcase(name)`