beads-kanban-ui 0.1.0

package/server/src/routes/projects.rs

@@ -0,0 +1,177 @@
+//! Project and Tag REST API routes
+//!
+//! Provides CRUD endpoints for projects, tags, and project-tag relationships.
+
+use axum::{
+    extract::{Path, State},
+    http::StatusCode,
+    Json,
+};
+use serde::Serialize;
+use std::sync::Arc;
+
+use crate::db::{
+    CreateProjectInput, CreateTagInput, Database, DbError, ProjectTagInput, ProjectWithTags, Tag,
+    UpdateProjectInput,
+};
+
+/// Application state containing the database
+pub type AppState = Arc<Database>;
+
+/// Error response structure
+#[derive(Serialize)]
+pub struct ErrorResponse {
+    pub error: String,
+}
+
+/// Success response structure for operations that don't return data
+#[derive(Serialize)]
+pub struct SuccessResponse {
+    pub success: bool,
+}
+
+impl DbError {
+    fn status_code(&self) -> StatusCode {
+        match self {
+            DbError::ProjectNotFound(_) | DbError::TagNotFound(_) => StatusCode::NOT_FOUND,
+            DbError::Sqlite(_) | DbError::PathError => StatusCode::INTERNAL_SERVER_ERROR,
+        }
+    }
+}
+
+fn db_error_response(err: DbError) -> (StatusCode, Json<ErrorResponse>) {
+    let status = err.status_code();
+    (
+        status,
+        Json(ErrorResponse {
+            error: err.to_string(),
+        }),
+    )
+}
+
+// ===== Project Routes =====
+
+/// GET /api/projects - List all projects with their tags
+pub async fn list_projects(
+    State(db): State<AppState>,
+) -> Result<Json<Vec<ProjectWithTags>>, (StatusCode, Json<ErrorResponse>)> {
+    db.get_projects_with_tags()
+        .map(Json)
+        .map_err(db_error_response)
+}
+
+/// POST /api/projects - Create a new project
+pub async fn create_project(
+    State(db): State<AppState>,
+    Json(input): Json<CreateProjectInput>,
+) -> Result<(StatusCode, Json<ProjectWithTags>), (StatusCode, Json<ErrorResponse>)> {
+    let project = db.create_project(input).map_err(db_error_response)?;
+
+    // Return project with empty tags array
+    let project_with_tags = ProjectWithTags {
+        id: project.id,
+        name: project.name,
+        path: project.path,
+        tags: vec![],
+        last_opened: project.last_opened,
+        created_at: project.created_at,
+    };
+
+    Ok((StatusCode::CREATED, Json(project_with_tags)))
+}
+
+/// PATCH /api/projects/:id - Update a project
+pub async fn update_project(
+    State(db): State<AppState>,
+    Path(id): Path<String>,
+    Json(input): Json<UpdateProjectInput>,
+) -> Result<Json<ProjectWithTags>, (StatusCode, Json<ErrorResponse>)> {
+    let project = db.update_project(&id, input).map_err(db_error_response)?;
+    let tags = db.get_project_tags(&id).map_err(db_error_response)?;
+
+    Ok(Json(ProjectWithTags {
+        id: project.id,
+        name: project.name,
+        path: project.path,
+        tags,
+        last_opened: project.last_opened,
+        created_at: project.created_at,
+    }))
+}
+
+/// DELETE /api/projects/:id - Delete a project
+pub async fn delete_project(
+    State(db): State<AppState>,
+    Path(id): Path<String>,
+) -> Result<StatusCode, (StatusCode, Json<ErrorResponse>)> {
+    db.delete_project(&id).map_err(db_error_response)?;
+    Ok(StatusCode::NO_CONTENT)
+}
+
+// ===== Tag Routes =====
+
+/// GET /api/tags - List all tags
+pub async fn list_tags(
+    State(db): State<AppState>,
+) -> Result<Json<Vec<Tag>>, (StatusCode, Json<ErrorResponse>)> {
+    db.get_tags().map(Json).map_err(db_error_response)
+}
+
+/// POST /api/tags - Create a new tag
+pub async fn create_tag(
+    State(db): State<AppState>,
+    Json(input): Json<CreateTagInput>,
+) -> Result<(StatusCode, Json<Tag>), (StatusCode, Json<ErrorResponse>)> {
+    let tag = db.create_tag(input).map_err(db_error_response)?;
+    Ok((StatusCode::CREATED, Json(tag)))
+}
+
+/// DELETE /api/tags/:id - Delete a tag
+pub async fn delete_tag(
+    State(db): State<AppState>,
+    Path(id): Path<String>,
+) -> Result<StatusCode, (StatusCode, Json<ErrorResponse>)> {
+    db.delete_tag(&id).map_err(db_error_response)?;
+    Ok(StatusCode::NO_CONTENT)
+}
+
+// ===== Project-Tag Relationship Routes =====
+
+/// POST /api/project-tags - Add a tag to a project
+pub async fn add_project_tag(
+    State(db): State<AppState>,
+    Json(input): Json<ProjectTagInput>,
+) -> Result<(StatusCode, Json<SuccessResponse>), (StatusCode, Json<ErrorResponse>)> {
+    db.add_tag_to_project(&input.project_id, &input.tag_id)
+        .map_err(db_error_response)?;
+    Ok((StatusCode::CREATED, Json(SuccessResponse { success: true })))
+}
+
+/// DELETE /api/project-tags/:project_id/:tag_id - Remove a tag from a project
+pub async fn remove_project_tag(
+    State(db): State<AppState>,
+    Path((project_id, tag_id)): Path<(String, String)>,
+) -> Result<Json<SuccessResponse>, (StatusCode, Json<ErrorResponse>)> {
+    db.remove_tag_from_project(&project_id, &tag_id)
+        .map_err(db_error_response)?;
+    Ok(Json(SuccessResponse { success: true }))
+}
+
+/// Creates the project/tag router with all routes
+pub fn project_routes() -> axum::Router<AppState> {
+    use axum::routing::{delete, get, patch, post};
+
+    axum::Router::new()
+        // Project routes
+        .route("/projects", get(list_projects).post(create_project))
+        .route(
+            "/projects/:id",
+            patch(update_project).delete(delete_project),
+        )
+        // Tag routes
+        .route("/tags", get(list_tags).post(create_tag))
+        .route("/tags/:id", delete(delete_tag))
+        // Project-tag relationship routes
+        .route("/project-tags", post(add_project_tag))
+        .route("/project-tags/:project_id/:tag_id", delete(remove_project_tag))
+}

package/server/src/routes/watch.rs

@@ -0,0 +1,211 @@
+//! File watcher SSE endpoint for real-time file change notifications.
+//!
+//! Provides Server-Sent Events for monitoring changes to beads issue files.
+
+use axum::{
+    extract::Query,
+    response::sse::{Event, Sse},
+};
+use futures::stream::Stream;
+use notify::{
+    event::ModifyKind, Config, EventKind, RecommendedWatcher, RecursiveMode, Watcher,
+};
+use serde::{Deserialize, Serialize};
+use std::{convert::Infallible, path::PathBuf, time::Duration};
+use tokio::sync::mpsc;
+use tokio_stream::wrappers::ReceiverStream;
+use tracing::{error, info, warn};
+
+/// Query parameters for the watch endpoint.
+#[derive(Debug, Deserialize)]
+pub struct WatchParams {
+    /// The project path to watch for changes.
+    pub path: String,
+}
+
+/// File change event sent to clients.
+#[derive(Debug, Serialize)]
+pub struct FileChangeEvent {
+    /// The path of the changed file.
+    pub path: String,
+    /// The type of change (modified, created, removed).
+    #[serde(rename = "type")]
+    pub change_type: String,
+}
+
+/// SSE endpoint for watching beads file changes.
+///
+/// Monitors the `.beads/issues.jsonl` file in the specified project path
+/// and sends SSE events when changes are detected.
+///
+/// # Query Parameters
+///
+/// - `path`: The project directory path to monitor
+///
+/// # Returns
+///
+/// A Server-Sent Events stream of file change notifications.
+pub async fn watch_beads(
+    Query(params): Query<WatchParams>,
+) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
+    let project_path = PathBuf::from(&params.path);
+    let beads_file = project_path.join(".beads").join("issues.jsonl");
+
+    info!("Starting file watcher for: {:?}", beads_file);
+
+    // Create channel for events with buffer for debouncing
+    let (tx, rx) = mpsc::channel::<Result<Event, Infallible>>(100);
+
+    // Spawn the watcher task
+    tokio::spawn(async move {
+        if let Err(e) = run_watcher(beads_file, tx).await {
+            error!("File watcher error: {}", e);
+        }
+    });
+
+    let stream = ReceiverStream::new(rx);
+    Sse::new(stream).keep_alive(
+        axum::response::sse::KeepAlive::new()
+            .interval(Duration::from_secs(30))
+            .text("ping"),
+    )
+}
+
+/// Runs the file watcher and sends events through the channel.
+async fn run_watcher(
+    beads_file: PathBuf,
+    tx: mpsc::Sender<Result<Event, Infallible>>,
+) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    // Create a channel for notify events
+    let (notify_tx, mut notify_rx) = mpsc::channel(100);
+
+    // Create the watcher
+    let mut watcher = RecommendedWatcher::new(
+        move |res: notify::Result<notify::Event>| {
+            if let Ok(event) = res {
+                // Only forward relevant events
+                let _ = notify_tx.blocking_send(event);
+            }
+        },
+        Config::default().with_poll_interval(Duration::from_millis(100)),
+    )?;
+
+    // Watch the parent directory (.beads) since the file might not exist yet
+    let watch_path = beads_file
+        .parent()
+        .map(|p| p.to_path_buf())
+        .unwrap_or_else(|| beads_file.clone());
+
+    // Create the .beads directory if it doesn't exist
+    if !watch_path.exists() {
+        warn!(
+            "Watch path does not exist, waiting for creation: {:?}",
+            watch_path
+        );
+    }
+
+    // Try to watch the path, or watch parent if it doesn't exist
+    let actual_watch_path = if watch_path.exists() {
+        watch_path.clone()
+    } else if let Some(parent) = watch_path.parent() {
+        if parent.exists() {
+            parent.to_path_buf()
+        } else {
+            error!("Neither watch path nor parent exists: {:?}", watch_path);
+            return Ok(());
+        }
+    } else {
+        error!("No valid path to watch: {:?}", watch_path);
+        return Ok(());
+    };
+
+    watcher.watch(&actual_watch_path, RecursiveMode::Recursive)?;
+    info!("File watcher active on: {:?}", actual_watch_path);
+
+    // Send initial connection event
+    let connect_event = Event::default().data(
+        serde_json::to_string(&FileChangeEvent {
+            path: beads_file.to_string_lossy().to_string(),
+            change_type: "connected".to_string(),
+        })
+        .unwrap_or_default(),
+    );
+    let _ = tx.send(Ok(connect_event)).await;
+
+    // Debounce state
+    let mut last_event_time = std::time::Instant::now();
+    let debounce_duration = Duration::from_millis(100);
+
+    // Process events
+    while let Some(event) = notify_rx.recv().await {
+        // Check if the event is for our target file
+        let is_relevant = event.paths.iter().any(|p| {
+            p.ends_with("issues.jsonl")
+                || p.ends_with(".beads")
+                || p == &beads_file
+        });
+
+        if !is_relevant {
+            continue;
+        }
+
+        // Debounce rapid changes
+        let now = std::time::Instant::now();
+        if now.duration_since(last_event_time) < debounce_duration {
+            continue;
+        }
+        last_event_time = now;
+
+        // Determine event type
+        let change_type = match event.kind {
+            EventKind::Create(_) => "created",
+            EventKind::Modify(ModifyKind::Data(_)) => "modified",
+            EventKind::Modify(_) => "modified",
+            EventKind::Remove(_) => "removed",
+            _ => continue, // Ignore other events
+        };
+
+        let file_event = FileChangeEvent {
+            path: beads_file.to_string_lossy().to_string(),
+            change_type: change_type.to_string(),
+        };
+
+        info!("File change detected: {:?}", file_event);
+
+        let sse_event = Event::default()
+            .data(serde_json::to_string(&file_event).unwrap_or_default());
+
+        // If send fails, client disconnected
+        if tx.send(Ok(sse_event)).await.is_err() {
+            info!("Client disconnected, stopping watcher");
+            break;
+        }
+    }
+
+    // Watcher is automatically dropped and cleaned up here
+    info!("File watcher stopped");
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_file_change_event_serialization() {
+        let event = FileChangeEvent {
+            path: "/test/path".to_string(),
+            change_type: "modified".to_string(),
+        };
+        let json = serde_json::to_string(&event).unwrap();
+        assert!(json.contains("\"path\":\"/test/path\""));
+        assert!(json.contains("\"type\":\"modified\""));
+    }
+
+    #[test]
+    fn test_watch_params_deserialization() {
+        let params: WatchParams =
+            serde_json::from_str(r#"{"path": "/test/project"}"#).unwrap();
+        assert_eq!(params.path, "/test/project");
+    }
+}

package/src/app/globals.css

@@ -0,0 +1,101 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@layer base {
+  :root {
+    --background: 0 0% 100%;
+    --foreground: 240 10% 3.9%;
+    --card: 0 0% 100%;
+    --card-foreground: 240 10% 3.9%;
+    --popover: 0 0% 100%;
+    --popover-foreground: 240 10% 3.9%;
+    --primary: 240 5.9% 10%;
+    --primary-foreground: 0 0% 98%;
+    --secondary: 240 4.8% 95.9%;
+    --secondary-foreground: 240 5.9% 10%;
+    --muted: 240 4.8% 95.9%;
+    --muted-foreground: 240 3.8% 46.1%;
+    --accent: 240 4.8% 95.9%;
+    --accent-foreground: 240 5.9% 10%;
+    --destructive: 0 84.2% 60.2%;
+    --destructive-foreground: 0 0% 98%;
+    --border: 240 5.9% 90%;
+    --input: 240 5.9% 90%;
+    --ring: 240 5.9% 10%;
+    --chart-1: 12 76% 61%;
+    --chart-2: 173 58% 39%;
+    --chart-3: 197 37% 24%;
+    --chart-4: 43 74% 66%;
+    --chart-5: 27 87% 67%;
+    --radius: 0.5rem;
+
+    /* Beads Status colors (HSL) */
+    --status-open: 217 91% 60%;
+    --status-in_progress: 38 92% 50%;
+    --status-inreview: 271 81% 56%;
+    --status-closed: 142 71% 45%;
+
+    /* Beads Priority colors (HSL) */
+    --priority-p0: 0 84% 60%;
+    --priority-p1: 25 95% 53%;
+    --priority-p2: 240 5% 65%;
+    --priority-p3: 240 5% 84%;
+    --priority-p4: 240 5% 84%;
+
+    /* Beads Accents (HSL) */
+    --blocked: 0 84% 60%;
+    --branch: 142 76% 36%;
+
+    /* roiui Card CSS Variables */
+    --shadow-border-stack: 0 1px 2px hsl(var(--foreground) / 0.04);
+    --mix-card-33-bg: hsl(var(--card) / 0.33);
+    --ease-in-out-quad: cubic-bezier(0.455, 0.03, 0.515, 0.955);
+    --background-muted: hsl(var(--muted));
+  }
+
+  .dark {
+    --background: 240 10% 3.9%;
+    --foreground: 0 0% 98%;
+    --card: 240 10% 3.9%;
+    --card-foreground: 0 0% 98%;
+    --popover: 240 10% 3.9%;
+    --popover-foreground: 0 0% 98%;
+    --primary: 0 0% 98%;
+    --primary-foreground: 240 5.9% 10%;
+    --secondary: 240 3.7% 15.9%;
+    --secondary-foreground: 0 0% 98%;
+    --muted: 240 3.7% 15.9%;
+    --muted-foreground: 240 5% 64.9%;
+    --accent: 240 3.7% 15.9%;
+    --accent-foreground: 0 0% 98%;
+    --destructive: 0 62.8% 30.6%;
+    --destructive-foreground: 0 0% 98%;
+    --border: 240 3.7% 15.9%;
+    --input: 240 3.7% 15.9%;
+    --ring: 240 4.9% 83.9%;
+    --chart-1: 220 70% 50%;
+    --chart-2: 160 60% 45%;
+    --chart-3: 30 80% 55%;
+    --chart-4: 280 65% 60%;
+    --chart-5: 340 75% 55%;
+  }
+}
+
+@layer base {
+  * {
+    @apply border-border;
+  }
+  body {
+    @apply bg-background text-foreground;
+    font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  }
+}
+
+.font-heading {
+  font-family: var(--font-space-grotesk), system-ui, sans-serif;
+}
+
+.font-project-name {
+  font-family: var(--font-plus-jakarta), system-ui, sans-serif;
+}

package/src/app/layout.tsx

@@ -0,0 +1,36 @@
+import type { Metadata } from 'next';
+import { Space_Grotesk, Plus_Jakarta_Sans } from 'next/font/google';
+import { Toaster } from '@/components/ui/toaster';
+import './globals.css';
+
+const spaceGrotesk = Space_Grotesk({
+  subsets: ['latin'],
+  display: 'swap',
+  variable: '--font-space-grotesk',
+});
+
+const plusJakartaSans = Plus_Jakarta_Sans({
+  subsets: ['latin'],
+  display: 'swap',
+  variable: '--font-plus-jakarta',
+});
+
+export const metadata: Metadata = {
+  title: 'Beads',
+  description: 'Kanban interface for beads - git-backed distributed issue tracker',
+};
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="en" className={`dark ${spaceGrotesk.variable} ${plusJakartaSans.variable}`}>
+      <body className="flex min-h-screen flex-col bg-background antialiased">
+        <div className="flex-1">{children}</div>
+        <Toaster />
+      </body>
+    </html>
+  );
+}