hanna/fabrica

feat(web): new-repository page and top-bar + button; full-width activity graph

de619b7 · hanna committed on 2026-07-25

Add a signed-in-only /new page (name, description, visibility, default
branch) that creates the repo row and bare repo on disk, plus a + button in
the top bar (left of search) linking to it. Stretch the contribution heatmap
to fill the activity column via width:100% on the viewBox'd SVG.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Signed by hannaSSH key fingerprint: SHA256:4g9cWhkAAw8gwqhJUcVbSnGEvdGwklW+1Aa/fMUu59k

assets/base.css +11 −1

crates/web/src/activity.rs +3 −1

crates/web/src/icons.rs +2 −0

crates/web/src/layout.rs +4 −0

crates/web/src/lib.rs +4 −0

crates/web/src/pages.rs +166 −0

crates/web/src/tests.rs +22 −0

+}
 /* Top-bar search: a growing input with an inline submit icon. */
+/* The new-repo button and search group at the right of the top bar. */
+.topbar-new {
+  margin-left: auto;
+}
 .topbar-search {
   display: flex;
   align-items: center;
   gap: 0.25rem;
   flex: 1;
   max-width: 28rem;
-  margin-left: auto;
+}
 .topbar-search input[type="search"] {
   width: 100%;
   display: none !important;
+}
+/* New-repository form: a comfortably narrow column. */
+.new-repo {
+  max-width: 42rem;
+}
 /* Centered auth card (sign in, invite activation). */
 .auth-wrap {
   display: flex;
+}
 .heatmap {
   display: block;
+  width: 100%;
+  height: auto;
+}
 .hm-label {
   fill: var(--fb-fg-muted);

         html! {
             div class="heatmap-wrap" {
+                // width:100% + the viewBox aspect ratio stretches the graph to
+                // fill the activity column (styled in base.css).
                 svg class="heatmap" viewBox=(format!("0 0 {width} {height}"))
-                    width=(width) height=(height) role="img"
+                    preserveAspectRatio="xMidYMid meet" role="img"
                     aria-label=(format!("{} contributions in the last year", self.total)) {
                     (PreEscaped(body))
+                }

     ChevronDown,
     Search,
     Copy,
+    Plus,
     Box,
     Link,
     User,
                 r#"<path d="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"/><path d="M3 3v5h5"/><path d="M12 7v5l4 2"/>"#
+            }
             Icon::ChevronDown => r#"<path d="m6 9 6 6 6-6"/>"#,
+            Icon::Plus => r#"<path d="M5 12h14"/><path d="M12 5v14"/>"#,
             Icon::Search => r#"<path d="m21 21-4.34-4.34"/><circle cx="11" cy="11" r="8"/>"#,
             Icon::Copy => {
                 r#"<rect width="14" height="14" x="8" y="8" rx="2" ry="2"/><path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"/>"#

             button class="icon-btn" type="button" data-drawer-toggle aria-label="Menu"
                    aria-controls="drawer" aria-expanded="false" { (icon(Icon::PanelLeft)) }
             span class="slug" { a href="/" { (chrome.instance_name) } }
+            @if chrome.user.is_some() {
+                a class="icon-btn topbar-new" href="/new" aria-label="New repository"
+                  title="New repository" { (icon(Icon::Plus)) }
+            }
             form class="topbar-search" method="get" action="/search" role="search" {
                 input type="search" name="q" placeholder="Search…" aria-label="Search";
+            }

     Router::new()
         .nest_service("/api/v1", api)
         .route("/", get(pages::home))
+        .route(
+            "/new",
+            get(pages::new_repo_form).post(pages::new_repo_submit),
+        )
         .route("/explore", get(pages::explore))
         .route("/explore/users", get(pages::explore_users))
         .route("/login", get(pages::login_form).post(pages::login_submit))

     })
+}
+/// `GET /new` — the new-repository form (requires sign-in).
+pub async fn new_repo_form(
+    State(state): State<AppState>,
+    RequireUser(user): RequireUser,
+    jar: CookieJar,
+    uri: Uri,
+) -> Response {
+    let (jar, chrome) = build_chrome(&state, jar, Some(user), uri.path().to_string());
+    let body = new_repo_body(&state, &chrome.csrf, None, "");
+    (jar, page(&chrome, "New repository", body)).into_response()
+}
+/// New-repository form fields.
+#[derive(Debug, Deserialize)]
+pub struct NewRepoForm {
+    /// The repo name (may include a group path).
+    #[serde(default)]
+    name: String,
+    /// Optional one-line description.
+    #[serde(default)]
+    description: String,
+    /// Visibility token (`public` | `internal` | `private`).
+    #[serde(default)]
+    visibility: String,
+    /// Optional default branch override.
+    #[serde(default)]
+    default_branch: String,
+    /// CSRF token.
+    #[serde(rename = "_csrf")]
+    csrf: String,
+}
+/// `POST /new` — create the repository (row + bare repo on disk) and redirect.
+pub async fn new_repo_submit(
+    State(state): State<AppState>,
+    RequireUser(user): RequireUser,
+    jar: CookieJar,
+    headers: HeaderMap,
+    Form(form): Form<NewRepoForm>,
+) -> Response {
+    if verify_csrf(&jar, &headers, Some(&form.csrf)).is_err() {
+        return AppError::Forbidden.into_response();
+    }
+    match create_repo_from_form(&state, &user, &form).await {
+        Ok(path) => Redirect::to(&format!("/{}/{path}", user.username)).into_response(),
+        Err(msg) => {
+            let (jar, chrome) = build_chrome(&state, jar, Some(user), "/new".to_string());
+            let body = new_repo_body(&state, &chrome.csrf, Some(&msg), form.name.trim());
+            (
+                axum::http::StatusCode::BAD_REQUEST,
+                jar,
+                page(&chrome, "New repository", body),
+            )
+                .into_response()
+        }
+    }
+}
+/// Create the repo described by `form`, returning its path or a user-facing error.
+async fn create_repo_from_form(
+    state: &AppState,
+    user: &User,
+    form: &NewRepoForm,
+) -> Result<String, String> {
+    let name = form.name.trim();
+    if name.is_empty() {
+        return Err("Repository name is required.".to_string());
+    }
+    let (group, leaf) = match name.rsplit_once('/') {
+        Some((g, l)) => (Some(g), l),
+        None => (None, name),
+    };
+    let group_id = match group {
+        Some(g) => Some(
+            state
+                .store
+                .ensure_group_path(&user.id, g)
+                .await
+                .map_err(|e| e.to_string())?
+                .id,
+        ),
+        None => None,
+    };
+    let branch = {
+        let b = form.default_branch.trim();
+        if b.is_empty() {
+            state.config.instance.default_branch.clone()
+        } else {
+            b.to_string()
+        }
+    };
+    let visibility = model::Visibility::from_token(&form.visibility).unwrap_or_else(|| {
+        model::Visibility::from_token(state.config.instance.default_visibility.as_token())
+            .unwrap_or(model::Visibility::Private)
+    });
+    let description = {
+        let d = form.description.trim();
+        (!d.is_empty()).then(|| d.to_string())
+    };
+    let repo = state
+        .store
+        .create_repo(store::NewRepo {
+            owner_id: user.id.clone(),
+            group_id,
+            name: leaf.to_string(),
+            path: name.to_string(),
+            description,
+            visibility,
+            default_branch: branch.clone(),
+        })
+        .await
+        .map_err(|e| match e {
+            store::StoreError::Conflict { .. } => {
+                "A repository with that name already exists.".to_string()
+            }
+            store::StoreError::Name(_) => {
+                "Invalid name: use letters, digits, '-', '_', and '/' for groups.".to_string()
+            }
+            other => other.to_string(),
+        })?;
+    let hook = std::env::current_exe().unwrap_or_else(|_| std::path::PathBuf::from("fabrica"));
+    if let Err(e) = git::create_bare(&state.config.storage.repo_dir, &repo.id, &branch, &hook) {
+        let _ = state.store.delete_repo(&repo.id).await;
+        return Err(format!("Could not create the repository on disk: {e}"));
+    }
+    Ok(repo.path)
+}
+/// Render the new-repository form with an optional error and prefilled name.
+fn new_repo_body(state: &AppState, csrf: &str, error: Option<&str>, name: &str) -> Markup {
+    let default_vis = state.config.instance.default_visibility.as_token();
+    let vis_option = |value: &str, label: &str| {
+        html! { option value=(value) selected[value == default_vis] { (label) } }
+    };
+    html! {
+        div class="new-repo" {
+            h1 { "New repository" }
+            @if let Some(err) = error {
+                div class="notice notice-error" { (err) }
+            }
+            div class="card" {
+                form method="post" action="/new" {
+                    input type="hidden" name="_csrf" value=(csrf);
+                    label for="name" { "Repository name" }
+                    input type="text" id="name" name="name" value=(name) required
+                          placeholder="my-project (or group/my-project)" autofocus;
+                    label for="description" { "Description" }
+                    input type="text" id="description" name="description"
+                          placeholder="Optional one-line description";
+                    label for="visibility" { "Visibility" }
+                    select id="visibility" name="visibility" {
+                        (vis_option("public", "Public — visible to everyone"))
+                        (vis_option("internal", "Internal — any signed-in user"))
+                        (vis_option("private", "Private — only you and collaborators"))
+                    }
+                    label for="default_branch" { "Default branch" }
+                    input type="text" id="default_branch" name="default_branch"
+                          placeholder=(state.config.instance.default_branch);
+                    button class="btn btn-primary" type="submit" { "Create repository" }
+                }
+            }
+        }
+    }
+}
 /// Sign-in form fields.
 #[derive(Debug, Deserialize)]
 pub struct LoginForm {

+}
 #[tokio::test]
+async fn new_repo_page_requires_auth_and_renders() {
+    let (_state, app) = app().await;
+    // Anonymous → redirected to sign in.
+    let res = app.clone().oneshot(get("/new")).await.unwrap();
+    assert_eq!(res.status(), StatusCode::SEE_OTHER);
+    assert_eq!(res.headers().get(header::LOCATION).unwrap(), "/login");
+    // Signed in → the creation form.
+    let cookie = login(&app).await;
+    let req = Request::builder()
+        .uri("/new")
+        .header(header::COOKIE, cookie)
+        .body(Body::empty())
+        .unwrap();
+    let res = app.oneshot(req).await.unwrap();
+    assert_eq!(res.status(), StatusCode::OK);
+    let html = body_string(res).await;
+    assert!(html.contains("New repository"));
+    assert!(html.contains("name=\"visibility\""));
+}
+#[tokio::test]
 async fn settings_requires_authentication() {
     let (_state, app) = app().await;
     let res = app.oneshot(get("/settings")).await.unwrap();