Merge pull request #33 from krazywarez/projects-crud

Projects: discovery, create, edit, manage linked resources (#12, #13, #14, #15)

5 files changed, 759 insertions, 2 deletions

diff --git a/Hutch/Views/Projects/DiscoverProjectsView.swift b/Hutch/Views/Projects/DiscoverProjectsView.swift
new file mode 100644
index 0000000..fab165e
--- /dev/null
+++ b/Hutch/Views/Projects/DiscoverProjectsView.swift
@@ -0,0 +1,166 @@
+import SwiftUI
+
+@Observable
+@MainActor
+final class DiscoverProjectsViewModel {
+    private(set) var projects: [DiscoveredProject] = []
+    private(set) var isLoading = false
+    private(set) var isLoadingMore = false
+    var error: String?
+
+    private var cursor: String?
+    private var canLoadMore = true
+    private let service: ProjectService
+
+    init(service: ProjectService) {
+        self.service = service
+    }
+
+    func loadInitial() async {
+        guard projects.isEmpty, !isLoading else { return }
+        isLoading = true
+        error = nil
+        defer { isLoading = false }
+
+        do {
+            let page = try await service.fetchPublicProjects(cursor: nil)
+            projects = page.projects
+            cursor = page.cursor
+            canLoadMore = page.cursor != nil
+        } catch {
+            self.error = error.userFacingMessage
+        }
+    }
+
+    func reload() async {
+        cursor = nil
+        canLoadMore = true
+        projects = []
+        await loadInitial()
+    }
+
+    func loadMoreIfNeeded(current item: DiscoveredProject) async {
+        guard canLoadMore, !isLoadingMore, !isLoading else { return }
+        guard let index = projects.firstIndex(of: item), index >= projects.count - 3 else { return }
+
+        isLoadingMore = true
+        defer { isLoadingMore = false }
+
+        do {
+            let page = try await service.fetchPublicProjects(cursor: cursor)
+            let existing = Set(projects.map(\.id))
+            projects.append(contentsOf: page.projects.filter { !existing.contains($0.id) })
+            cursor = page.cursor
+            canLoadMore = page.cursor != nil
+        } catch {
+            self.error = error.userFacingMessage
+        }
+    }
+}
+
+struct DiscoverProjectsView: View {
+    @Environment(AppState.self) private var appState
+    @State private var viewModel: DiscoverProjectsViewModel?
+
+    var body: some View {
+        Group {
+            if let viewModel {
+                content(viewModel)
+            } else {
+                SRHTLoadingStateView(message: "Loading projects…")
+            }
+        }
+        .navigationTitle("Discover")
+        .navigationBarTitleDisplayMode(.inline)
+        .task {
+            if viewModel == nil {
+                let vm = DiscoverProjectsViewModel(service: ProjectService(client: appState.client))
+                viewModel = vm
+                await vm.loadInitial()
+            }
+        }
+    }
+
+    @ViewBuilder
+    private func content(_ viewModel: DiscoverProjectsViewModel) -> some View {
+        List {
+            ForEach(viewModel.projects) { discovered in
+                NavigationLink {
+                    ProjectDetailView(
+                        project: discovered.project,
+                        canManage: discovered.ownerCanonicalName == appState.currentUser?.canonicalName
+                    )
+                } label: {
+                    DiscoveredProjectRow(discovered: discovered)
+                }
+                .buttonStyle(.plain)
+                .task {
+                    await viewModel.loadMoreIfNeeded(current: discovered)
+                }
+            }
+            .themedRow()
+
+            if viewModel.isLoadingMore {
+                HStack {
+                    Spacer()
+                    ProgressView()
+                    Spacer()
+                }
+                .listRowSeparator(.hidden)
+                .themedRow()
+            }
+        }
+        .themedList()
+        .listStyle(.plain)
+        .overlay {
+            if viewModel.isLoading, viewModel.projects.isEmpty {
+                SRHTLoadingStateView(message: "Loading projects…")
+            } else if let error = viewModel.error, viewModel.projects.isEmpty {
+                SRHTErrorStateView(
+                    title: "Couldn't Load Projects",
+                    message: error,
+                    retryAction: { await viewModel.reload() }
+                )
+            } else if viewModel.projects.isEmpty {
+                ContentUnavailableView(
+                    "No Public Projects",
+                    systemImage: "sparkle.magnifyingglass",
+                    description: Text("Public projects on SourceHut will appear here.")
+                )
+            }
+        }
+        .srhtErrorBanner(
+            error: Binding(
+                get: { viewModel.error },
+                set: { viewModel.error = $0 }
+            )
+        )
+        .refreshable {
+            await viewModel.reload()
+        }
+    }
+}
+
+private struct DiscoveredProjectRow: View {
+    let discovered: DiscoveredProject
+
+    private var project: Project { discovered.project }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 4) {
+            Text(project.displayName)
+                .font(.headline)
+                .lineLimit(1)
+            Text(discovered.ownerCanonicalName)
+                .font(.caption)
+                .foregroundStyle(.secondary)
+            if let description = project.displayDescription {
+                Text(description)
+                    .font(.subheadline)
+                    .foregroundStyle(.secondary)
+                    .lineLimit(2)
+            }
+        }
+        .padding(.vertical, 2)
+    }
+}
diff --git a/Hutch/Views/Projects/ManageProjectResourcesView.swift b/Hutch/Views/Projects/ManageProjectResourcesView.swift
new file mode 100644
index 0000000..5769d17
--- /dev/null
+++ b/Hutch/Views/Projects/ManageProjectResourcesView.swift
@@ -0,0 +1,303 @@
+import SwiftUI
+
+@Observable
+@MainActor
+final class ManageProjectResourcesViewModel {
+    private(set) var sources: [Project.SourceRepo]
+    private(set) var trackers: [Project.Tracker]
+    private(set) var mailingLists: [Project.MailingList]
+    private(set) var busyID: String?
+    var error: String?
+
+    let projectID: String
+    let projectName: String
+    private let service: ProjectService
+    private let onChange: () async -> Void
+
+    init(project: Project, service: ProjectService, onChange: @escaping () async -> Void) {
+        projectID = project.id
+        projectName = project.displayName
+        sources = project.sources
+        trackers = project.trackers
+        mailingLists = project.mailingLists
+        self.service = service
+        self.onChange = onChange
+    }
+
+    /// rids already linked, so the candidate pickers can hide them.
+    var linkedRIDs: Set<String> {
+        Set(sources.map(\.id) + trackers.map(\.id) + mailingLists.map(\.id))
+    }
+
+    func unlink(source: Project.SourceRepo) async {
+        await mutate(id: source.id) {
+            try await self.service.unlinkSource(projectID: self.projectID, sourceRepoID: source.id)
+            self.sources.removeAll { $0.id == source.id }
+        }
+    }
+
+    func unlink(tracker: Project.Tracker) async {
+        await mutate(id: tracker.id) {
+            try await self.service.unlinkTracker(projectID: self.projectID, trackerID: tracker.id)
+            self.trackers.removeAll { $0.id == tracker.id }
+        }
+    }
+
+    func unlink(mailingList: Project.MailingList) async {
+        await mutate(id: mailingList.id) {
+            try await self.service.unlinkMailingList(projectID: self.projectID, listID: mailingList.id)
+            self.mailingLists.removeAll { $0.id == mailingList.id }
+        }
+    }
+
+    func link(_ resource: LinkableResource) async {
+        await mutate(id: resource.rid) {
+            switch resource.kind {
+            case .source:
+                try await self.service.linkSource(projectID: self.projectID, sourceRepoID: resource.rid)
+            case .tracker:
+                try await self.service.linkTracker(projectID: self.projectID, trackerID: resource.rid)
+            case .mailingList:
+                try await self.service.linkMailingList(projectID: self.projectID, listID: resource.rid)
+            }
+            try await self.reload()
+        }
+    }
+
+    func candidates(for kind: LinkableResource.Kind) async throws -> [LinkableResource] {
+        let all: [LinkableResource]
+        switch kind {
+        case .source: all = try await service.fetchLinkableSources()
+        case .tracker: all = try await service.fetchLinkableTrackers()
+        case .mailingList: all = try await service.fetchLinkableMailingLists()
+        }
+        let linked = linkedRIDs
+        return all.filter { !linked.contains($0.rid) }
+    }
+
+    private func reload() async throws {
+        let project = try await service.fetchProjectDetail(rid: projectID)
+        sources = project.sources
+        trackers = project.trackers
+        mailingLists = project.mailingLists
+    }
+
+    private func mutate(id: String, _ work: @escaping () async throws -> Void) async {
+        guard busyID == nil else { return }
+        busyID = id
+        error = nil
+        defer { busyID = nil }
+        do {
+            try await work()
+            await onChange()
+        } catch {
+            self.error = error.userFacingMessage
+        }
+    }
+}
+
+struct ManageProjectResourcesView: View {
+    let project: Project
+    let onChange: () async -> Void
+
+    @Environment(AppState.self) private var appState
+    @Environment(\.dismiss) private var dismiss
+    @State private var viewModel: ManageProjectResourcesViewModel?
+    @State private var addKind: LinkableResource.Kind?
+
+    var body: some View {
+        NavigationStack {
+            Group {
+                if let viewModel {
+                    content(viewModel)
+                } else {
+                    SRHTLoadingStateView(message: "Loading…")
+                }
+            }
+            .navigationTitle("Linked Resources")
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .confirmationAction) {
+                    Button("Done") { dismiss() }
+                }
+                ToolbarItem(placement: .topBarLeading) {
+                    Menu {
+                        Button("Add Repository") { addKind = .source }
+                        Button("Add Tracker") { addKind = .tracker }
+                        Button("Add Mailing List") { addKind = .mailingList }
+                    } label: {
+                        Image(systemName: "plus")
+                    }
+                    .accessibilityLabel("Add linked resource")
+                }
+            }
+            .sheet(item: Binding(get: { addKind.map { AddKind(kind: $0) } }, set: { addKind = $0?.kind })) { wrapper in
+                if let viewModel {
+                    LinkableResourcePicker(kind: wrapper.kind, viewModel: viewModel)
+                }
+            }
+        }
+        .task {
+            if viewModel == nil {
+                viewModel = ManageProjectResourcesViewModel(
+                    project: project,
+                    service: ProjectService(client: appState.client),
+                    onChange: onChange
+                )
+            }
+        }
+    }
+
+    @ViewBuilder
+    private func content(_ viewModel: ManageProjectResourcesViewModel) -> some View {
+        List {
+            resourceSection(
+                title: "Repositories",
+                items: viewModel.sources,
+                busyID: viewModel.busyID,
+                label: { "\($0.ownerUsername)/\($0.displayName)" },
+                onDelete: { await viewModel.unlink(source: $0) }
+            )
+            resourceSection(
+                title: "Trackers",
+                items: viewModel.trackers,
+                busyID: viewModel.busyID,
+                label: { "\($0.ownerUsername)/\($0.displayName)" },
+                onDelete: { await viewModel.unlink(tracker: $0) }
+            )
+            resourceSection(
+                title: "Mailing Lists",
+                items: viewModel.mailingLists,
+                busyID: viewModel.busyID,
+                label: { "\($0.ownerUsername)/\($0.displayName)" },
+                onDelete: { await viewModel.unlink(mailingList: $0) }
+            )
+
+            if viewModel.sources.isEmpty, viewModel.trackers.isEmpty, viewModel.mailingLists.isEmpty {
+                Section {
+                    Text("No linked resources. Use + to add repositories, trackers, or mailing lists.")
+                        .foregroundStyle(.secondary)
+                        .themedRow()
+                }
+            }
+        }
+        .themedList()
+        .srhtErrorBanner(
+            error: Binding(get: { viewModel.error }, set: { viewModel.error = $0 })
+        )
+    }
+
+    @ViewBuilder
+    private func resourceSection<Item: Identifiable>(
+        title: String,
+        items: [Item],
+        busyID: String?,
+        label: @escaping (Item) -> String,
+        onDelete: @escaping (Item) async -> Void
+    ) -> some View where Item.ID == String {
+        if !items.isEmpty {
+            Section(title) {
+                ForEach(items) { item in
+                    HStack {
+                        Text(label(item))
+                            .font(.body.monospaced())
+                            .lineLimit(1)
+                        Spacer()
+                        if busyID == item.id {
+                            ProgressView().controlSize(.small)
+                        }
+                    }
+                    .themedRow()
+                    .swipeActions(edge: .trailing, allowsFullSwipe: true) {
+                        Button(role: .destructive) {
+                            Task { await onDelete(item) }
+                        } label: {
+                            Label("Unlink", systemImage: "link.badge.minus")
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+private struct AddKind: Identifiable {
+    let kind: LinkableResource.Kind
+    var id: String {
+        switch kind {
+        case .source: "source"
+        case .tracker: "tracker"
+        case .mailingList: "mailingList"
+        }
+    }
+}
+
+private struct LinkableResourcePicker: View {
+    let kind: LinkableResource.Kind
+    let viewModel: ManageProjectResourcesViewModel
+
+    @Environment(\.dismiss) private var dismiss
+    @State private var candidates: [LinkableResource] = []
+    @State private var isLoading = true
+    @State private var error: String?
+
+    private var title: String {
+        switch kind {
+        case .source: "Add Repository"
+        case .tracker: "Add Tracker"
+        case .mailingList: "Add Mailing List"
+        }
+    }
+
+    var body: some View {
+        NavigationStack {
+            Group {
+                if isLoading {
+                    SRHTLoadingStateView(message: "Loading…")
+                } else if let error {
+                    SRHTErrorStateView(title: "Couldn't Load", message: error, retryAction: { await load() })
+                } else if candidates.isEmpty {
+                    ContentUnavailableView(
+                        "Nothing to Add",
+                        systemImage: "checkmark.circle",
+                        description: Text("There are no more resources of this type to link.")
+                    )
+                } else {
+                    List(candidates) { candidate in
+                        Button {
+                            Task {
+                                await viewModel.link(candidate)
+                                dismiss()
+                            }
+                        } label: {
+                            Text(candidate.displayName)
+                                .font(.body.monospaced())
+                                .lineLimit(1)
+                        }
+                        .themedRow()
+                    }
+                    .themedList()
+                }
+            }
+            .navigationTitle(title)
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .cancellationAction) {
+                    Button("Cancel") { dismiss() }
+                }
+            }
+        }
+        .task { await load() }
+    }
+
+    private func load() async {
+        isLoading = true
+        error = nil
+        do {
+            candidates = try await viewModel.candidates(for: kind)
+        } catch {
+            self.error = error.userFacingMessage
+        }
+        isLoading = false
+    }
+}
diff --git a/Hutch/Views/Projects/ProjectDetailView.swift b/Hutch/Views/Projects/ProjectDetailView.swift
index c30ec88..0685a83 100644
--- a/Hutch/Views/Projects/ProjectDetailView.swift
+++ b/Hutch/Views/Projects/ProjectDetailView.swift
@@ -2,6 +2,7 @@ import SwiftUI
 
 struct ProjectDetailView: View {
     let project: Project
+    var canManage: Bool = false
 
     @Environment(AppState.self) private var appState
     @Environment(\.dismiss) private var dismiss
@@ -10,6 +11,14 @@ struct ProjectDetailView: View {
     @State private var isLoading = false
     @State private var error: String?
     @State private var pinChangeCount = 0
+    @State private var isPresentingEdit = false
+    @State private var isPresentingManage = false
+    @State private var isSavingEdit = false
+    @State private var editError: String?
+
+    private var projectService: ProjectService {
+        ProjectService(client: appState.client)
+    }
 
     private var displayedProject: Project {
         detailProject ?? project
@@ -59,6 +68,46 @@ struct ProjectDetailView: View {
                     .accessibilityLabel(isPinnedToHome ? "Unpin from Home" : "Pin to Home")
                 }
             }
+            if canManage {
+                ToolbarItem(placement: .topBarTrailing) {
+                    Menu {
+                        Button {
+                            editError = nil
+                            isPresentingEdit = true
+                        } label: {
+                            Label("Edit Project", systemImage: "pencil")
+                        }
+                        Button {
+                            isPresentingManage = true
+                        } label: {
+                            Label("Manage Resources", systemImage: "link")
+                        }
+                    } label: {
+                        Image(systemName: "ellipsis.circle")
+                    }
+                    .accessibilityLabel("Manage project")
+                }
+            }
+        }
+        .sheet(isPresented: $isPresentingEdit) {
+            ProjectFormSheet(
+                title: "Edit Project",
+                confirmationTitle: "Save",
+                isSaving: isSavingEdit,
+                error: editError,
+                includeWebsite: true,
+                initialName: displayedProject.name,
+                initialDescription: displayedProject.description ?? "",
+                initialWebsite: displayedProject.website ?? "",
+                initialTags: displayedProject.tags,
+                initialVisibility: displayedProject.visibility,
+                onSave: { await saveEdits($0) }
+            )
+        }
+        .sheet(isPresented: $isPresentingManage) {
+            ManageProjectResourcesView(project: displayedProject) {
+                await loadProjectIfNeeded(forceRefresh: true)
+            }
         }
         .task {
             await loadProjectIfNeeded()
@@ -69,6 +118,47 @@ struct ProjectDetailView: View {
         .srhtErrorBanner(error: $error)
     }
 
+    private func saveEdits(_ values: ProjectFormValues) async -> Bool {
+        guard !isSavingEdit else { return false }
+        isSavingEdit = true
+        editError = nil
+        defer { isSavingEdit = false }
+
+        do {
+            let updated = try await projectService.updateProject(
+                rid: displayedProject.id,
+                name: values.name,
+                description: values.description,
+                website: values.website,
+                visibility: values.visibility,
+                tags: values.tags
+            )
+            // Preserve already-loaded linked resources; the mutation returns metadata only.
+            detailProject = Project(
+                metadata: .init(
+                    id: updated.id,
+                    name: updated.name,
+                    description: updated.description,
+                    website: updated.website,
+                    visibility: updated.visibility,
+                    tags: updated.tags,
+                    updated: updated.updated
+                ),
+                resources: .init(
+                    mailingLists: displayedProject.mailingLists,
+                    sources: displayedProject.sources,
+                    trackers: displayedProject.trackers,
+                    isFullyLoaded: displayedProject.isFullyLoaded
+                )
+            )
+            await loadProjectIfNeeded(forceRefresh: true)
+            return true
+        } catch {
+            editError = error.userFacingMessage
+            return false
+        }
+    }
+
     @ViewBuilder
     private var headerSection: some View {
         Section {
diff --git a/Hutch/Views/Projects/ProjectFormSheet.swift b/Hutch/Views/Projects/ProjectFormSheet.swift
new file mode 100644
index 0000000..b05ae66
--- /dev/null
+++ b/Hutch/Views/Projects/ProjectFormSheet.swift
@@ -0,0 +1,144 @@
+import SwiftUI
+
+/// Shared create/edit form for hub.sr.ht projects. The parent owns the save
+/// state and performs the mutation via `onSave`, dismissing on success.
+struct ProjectFormSheet: View {
+    let title: String
+    let confirmationTitle: String
+    let isSaving: Bool
+    let error: String?
+    /// `createProject` takes no website; only the edit flow shows the field.
+    let includeWebsite: Bool
+    let onSave: (ProjectFormValues) async -> Bool
+
+    @Environment(\.dismiss) private var dismiss
+    @State private var name: String
+    @State private var description: String
+    @State private var website: String
+    @State private var tags: String
+    @State private var visibility: Visibility
+
+    init(
+        title: String,
+        confirmationTitle: String,
+        isSaving: Bool,
+        error: String?,
+        includeWebsite: Bool,
+        initialName: String = "",
+        initialDescription: String = "",
+        initialWebsite: String = "",
+        initialTags: [String] = [],
+        initialVisibility: Visibility = .publicVisibility,
+        onSave: @escaping (ProjectFormValues) async -> Bool
+    ) {
+        self.title = title
+        self.confirmationTitle = confirmationTitle
+        self.isSaving = isSaving
+        self.error = error
+        self.includeWebsite = includeWebsite
+        self.onSave = onSave
+        _name = State(initialValue: initialName)
+        _description = State(initialValue: initialDescription)
+        _website = State(initialValue: initialWebsite)
+        _tags = State(initialValue: initialTags.joined(separator: ", "))
+        _visibility = State(initialValue: initialVisibility)
+    }
+
+    private var trimmedName: String {
+        name.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    var body: some View {
+        NavigationStack {
+            Form {
+                Section("Project Details") {
+                    TextField("Project name", text: $name)
+                        .textInputAutocapitalization(.never)
+                        .autocorrectionDisabled()
+                        .themedRow()
+                    TextField("Description (optional)", text: $description, axis: .vertical)
+                        .lineLimit(2...4)
+                        .themedRow()
+                    if includeWebsite {
+                        TextField("Website (optional)", text: $website)
+                            .textInputAutocapitalization(.never)
+                            .autocorrectionDisabled()
+                            .keyboardType(.URL)
+                            .themedRow()
+                    }
+                    Picker("Visibility", selection: $visibility) {
+                        Text("Public").tag(Visibility.publicVisibility)
+                        Text("Unlisted").tag(Visibility.unlisted)
+                        Text("Private").tag(Visibility.privateVisibility)
+                    }
+                    .themedRow()
+                }
+
+                Section {
+                    TextField("Tags (comma separated)", text: $tags)
+                        .textInputAutocapitalization(.never)
+                        .autocorrectionDisabled()
+                        .themedRow()
+                } footer: {
+                    Text("Separate tags with commas.")
+                }
+
+                if let error, !error.isEmpty {
+                    Section {
+                        Text(error)
+                            .foregroundStyle(.red)
+                            .themedRow()
+                    }
+                }
+            }
+            .themedList()
+            .navigationTitle(title)
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .cancellationAction) {
+                    Button("Cancel") { dismiss() }
+                }
+                ToolbarItem(placement: .confirmationAction) {
+                    Button {
+                        Task {
+                            let values = ProjectFormValues(
+                                name: trimmedName,
+                                description: description.trimmingCharacters(in: .whitespacesAndNewlines),
+                                website: website.trimmingCharacters(in: .whitespacesAndNewlines),
+                                visibility: visibility,
+                                tags: Self.parseTags(tags)
+                            )
+                            if await onSave(values) {
+                                dismiss()
+                            }
+                        }
+                    } label: {
+                        if isSaving {
+                            ProgressView().controlSize(.small)
+                        } else {
+                            Text(confirmationTitle)
+                        }
+                    }
+                    .disabled(trimmedName.isEmpty || isSaving)
+                }
+            }
+        }
+    }
+
+    static func parseTags(_ raw: String) -> [String] {
+        var seen = Set<String>()
+        return raw
+            .split(whereSeparator: { $0 == "," || $0.isNewline })
+            .map { $0.trimmingCharacters(in: .whitespaces) }
+            .filter { !$0.isEmpty }
+            .filter { seen.insert($0.lowercased()).inserted }
+    }
+}
+
+struct ProjectFormValues: Sendable {
+    let name: String
+    let description: String
+    let website: String
+    let visibility: Visibility
+    let tags: [String]
+}
diff --git a/Hutch/Views/Projects/ProjectsListView.swift b/Hutch/Views/Projects/ProjectsListView.swift
index 783417c..1a34346 100644
--- a/Hutch/Views/Projects/ProjectsListView.swift
+++ b/Hutch/Views/Projects/ProjectsListView.swift
@@ -5,15 +5,38 @@ import SwiftUI
 final class ProjectsListViewModel {
     private(set) var projects: [Project] = []
     private(set) var isLoading = false
+    private(set) var isSaving = false
     var error: String?
+    var saveError: String?
     var searchText = ""
 
-    private let service: ProjectService
+    let service: ProjectService
 
     init(service: ProjectService) {
         self.service = service
     }
 
+    func createProject(_ values: ProjectFormValues) async -> Bool {
+        guard !isSaving else { return false }
+        isSaving = true
+        saveError = nil
+        defer { isSaving = false }
+
+        do {
+            _ = try await service.createProject(
+                name: values.name,
+                visibility: values.visibility,
+                description: values.description.isEmpty ? nil : values.description,
+                tags: values.tags
+            )
+            await loadProjects(forceRefresh: true)
+            return true
+        } catch {
+            saveError = error.userFacingMessage
+            return false
+        }
+    }
+
     var filteredProjects: [Project] {
         let query = searchText.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
         guard !query.isEmpty else { return projects }
@@ -46,11 +69,42 @@ final class ProjectsListViewModel {
 struct ProjectsListView: View {
     @Environment(AppState.self) private var appState
     @State private var viewModel: ProjectsListViewModel?
+    @State private var isPresentingCreate = false
 
     var body: some View {
         Group {
             if let viewModel {
                 content(viewModel)
+                    .toolbar {
+                        ToolbarItem(placement: .topBarTrailing) {
+                            NavigationLink {
+                                DiscoverProjectsView()
+                            } label: {
+                                Image(systemName: "sparkle.magnifyingglass")
+                            }
+                            .accessibilityLabel("Discover public projects")
+                        }
+                        if appState.currentUser != nil {
+                            ToolbarItem(placement: .topBarTrailing) {
+                                Button {
+                                    isPresentingCreate = true
+                                } label: {
+                                    Image(systemName: "plus")
+                                }
+                                .accessibilityLabel("Create project")
+                            }
+                        }
+                    }
+                    .sheet(isPresented: $isPresentingCreate) {
+                        ProjectFormSheet(
+                            title: "New Project",
+                            confirmationTitle: "Create",
+                            isSaving: viewModel.isSaving,
+                            error: viewModel.saveError,
+                            includeWebsite: false,
+                            onSave: { await viewModel.createProject($0) }
+                        )
+                    }
             } else {
                 SRHTLoadingStateView(message: "Loading projects…")
             }
@@ -70,7 +124,7 @@ struct ProjectsListView: View {
         List {
             ForEach(viewModel.filteredProjects) { project in
                 NavigationLink {
-                    ProjectDetailView(project: project)
+                    ProjectDetailView(project: project, canManage: true)
                 } label: {
                     ProjectListRow(project: project)
                 }