From 80085c7cfa9d679ed3e3fd54a7d55fa8ab1addef Mon Sep 17 00:00:00 2001 From: soryu Date: Fri, 1 May 2026 18:06:38 +0100 Subject: feat(doc-mode): unified surface — ephemeral tasks, tmp/, /exec redirect, palette, SWR (#117) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Phases 1-3 of the unified-surface plan, bundled per the user's request. The directive document/folder UI is now the canonical place to interact with makima; legacy /exec is subsumed by routing redirects, /contracts is already hidden in nav, and orphan tasks surface under a top-level tmp/ pseudo-folder. Phase 4 (porting contract-only features) was confirmed out of scope; Phase 5 (deleting the contracts code) is a follow-up. ## Backend - New migration `20260501000000_archive_existing_contracts.sql` flips every legacy contract to `archived` so /contracts is read-only history. - New endpoint `POST /api/v1/directives/{id}/tasks` creates an ephemeral task — `directive_id` set, `directive_step_id` NULL, repo/branch inherited from the directive. Reuses `create_task_for_owner`. - New endpoint `GET /api/v1/directives/{id}/tasks` lists ephemeral tasks attached to a directive (drives the per-folder ephemeral group). - `GET /api/v1/mesh/tasks?orphan=true` returns top-level tasks with no `directive_id` AND no `parent_task_id` — backs the sidebar's tmp/. - New repo helpers `list_ephemeral_directive_tasks_for_owner` and `list_orphan_tasks_for_owner`. - The existing `mesh_merge` endpoints are reused as-is for ephemeral task merge (no new merge logic needed). ## Frontend ### Sticky composer + auto-scroll fix (`DocumentTaskStream.tsx`) - Sticky comment composer pinned to viewport bottom; padding compensates so the last entry isn't hidden behind it. - `autoScroll` now resumes when the user scrolls back within 80px of the bottom (previously stuck off forever after a single scroll-up). - Floating "↓ Jump to latest" chip when the user has scrolled away. - Action header strip: explicit Stop / Send / Open-in-task-page + conditional "Merge to base ↗" button on ephemeral terminal tasks. - Module-level cache of historical entries by taskId so re-selecting a task you've viewed renders instantly while a fresh fetch runs. ### Sidebar (`document-directives.tsx`) - Top-level `tmp/` folder: orphan tasks, polled every 5s. - Per-directive `tasks/` subfolder now also surfaces ephemeral tasks (lazily fetched on folder open) with a distinct asterisk-on-terminal icon (`EphemeralTaskIcon`). - Inline hover-action chips on each directive folder header: Start / Pause / PR / +New task. Right-click menu still works as a power-user fallback. - "Now executing" amber strip in the editor pane: surfaces the live orchestrator/completion/running-step task with a one-click jump. - Inline `+ New task` modal (name + plan); on submit calls `createDirectiveTask` and navigates into the freshly-spawned task. - New `EphemeralAwareTaskStream` wrapper passes `ephemeral` and `status` to `DocumentTaskStream` so the merge button only shows when the selected task is genuinely an ephemeral spinoff in a terminal state. Step-spawned tasks merge via the directive's PR completion. ### SWR cache (`useDirectives.ts`) - Module-level `listCache` and per-id `detailCache` (mirrors the pattern in `useUserSettings.ts`). Mounting the hook renders the cache value immediately if present and kicks a background refresh; subscribers see the new value when it lands. Cuts perceived navigation latency to near-zero on warm cache hits. ### QuickSwitcher (`QuickSwitcher.tsx`, new) - IntelliJ-style double-Shift command palette mounted at app root. - Listens at the document level for two `Shift` keydowns within 300ms with no other key in between; ignores while focus is in an input/textarea so capitalising letters doesn't pop the palette. - Searches across directives + their tasks (orchestrator/completion/ steps/ephemerals) + orphan tmp tasks. Fuzzy matches on title. - Eagerly loads task details for the first 20 directives on open so searches don't block on per-directive fetches. ### Routing (`main.tsx` + `exec-redirect.tsx` + `tmp.tsx`) - New `ExecRedirect` wrapper at `/exec/:id`: when documentMode is on AND the task has a `directiveId`, replaces the URL with `/directives/?task=`. Otherwise renders the legacy `MeshPage` as before. - New `/tmp/:taskId` route renders `DocumentTaskStream` standalone for orphan tasks, with the masthead and a `tmp / ` breadcrumb. Co-authored-by: Claude Opus 4.7 (1M context) --- makima/src/db/repository.rs | 65 +++++++++++++ makima/src/server/handlers/directives.rs | 161 +++++++++++++++++++++++++++++++ makima/src/server/handlers/mesh.rs | 25 ++++- makima/src/server/mod.rs | 4 + makima/src/server/openapi.rs | 3 + 5 files changed, 256 insertions(+), 2 deletions(-) (limited to 'makima/src') diff --git a/makima/src/db/repository.rs b/makima/src/db/repository.rs index 27bd47e..b41c74c 100644 --- a/makima/src/db/repository.rs +++ b/makima/src/db/repository.rs @@ -1189,6 +1189,71 @@ pub async fn list_tasks_for_owner( .await } +/// List ephemeral tasks attached to a directive — tasks with `directive_id` +/// set but no `directive_step_id`. These are the "spinoff" tasks the user +/// created via the directive folder context menu, distinct from +/// step-spawned execution tasks. Hidden tasks excluded. +pub async fn list_ephemeral_directive_tasks_for_owner( + pool: &PgPool, + owner_id: Uuid, + directive_id: Uuid, +) -> Result, sqlx::Error> { + sqlx::query_as::<_, TaskSummary>( + r#" + SELECT + t.id, t.contract_id, c.name as contract_name, c.phase as contract_phase, + c.status as contract_status, + t.parent_task_id, t.depth, t.name, t.status, t.priority, + t.progress_summary, + (SELECT COUNT(*) FROM tasks WHERE parent_task_id = t.id) as subtask_count, + t.version, t.is_supervisor, COALESCE(t.hidden, false) as hidden, t.created_at, t.updated_at + FROM tasks t + LEFT JOIN contracts c ON t.contract_id = c.id + WHERE t.owner_id = $1 + AND t.directive_id = $2 + AND t.directive_step_id IS NULL + AND t.parent_task_id IS NULL + AND COALESCE(t.hidden, false) = false + ORDER BY t.created_at DESC + "#, + ) + .bind(owner_id) + .bind(directive_id) + .fetch_all(pool) + .await +} + +/// List "orphan" top-level tasks for an owner — tasks that are NOT attached +/// to a directive and NOT a subtask of another task. These surface in the +/// document-mode sidebar under a top-level `tmp/` folder. Hidden tasks +/// excluded. +pub async fn list_orphan_tasks_for_owner( + pool: &PgPool, + owner_id: Uuid, +) -> Result, sqlx::Error> { + sqlx::query_as::<_, TaskSummary>( + r#" + SELECT + t.id, t.contract_id, c.name as contract_name, c.phase as contract_phase, + c.status as contract_status, + t.parent_task_id, t.depth, t.name, t.status, t.priority, + t.progress_summary, + (SELECT COUNT(*) FROM tasks WHERE parent_task_id = t.id) as subtask_count, + t.version, t.is_supervisor, COALESCE(t.hidden, false) as hidden, t.created_at, t.updated_at + FROM tasks t + LEFT JOIN contracts c ON t.contract_id = c.id + WHERE t.owner_id = $1 + AND t.parent_task_id IS NULL + AND t.directive_id IS NULL + AND COALESCE(t.hidden, false) = false + ORDER BY t.priority DESC, t.created_at DESC + "#, + ) + .bind(owner_id) + .fetch_all(pool) + .await +} + /// List subtasks of a parent task, scoped to owner. pub async fn list_subtasks_for_owner( pool: &PgPool, diff --git a/makima/src/server/handlers/directives.rs b/makima/src/server/handlers/directives.rs index 7a7aff4..7b13f1c 100644 --- a/makima/src/server/handlers/directives.rs +++ b/makima/src/server/handlers/directives.rs @@ -12,6 +12,7 @@ use crate::db::models::{ CleanupResponse, CreateDirectiveRequest, CreateTaskRequest, CreateDirectiveStepRequest, Directive, DirectiveListResponse, DirectiveRevision, DirectiveStep, DirectiveWithSteps, PickUpOrdersResponse, + Task, UpdateDirectiveRequest, UpdateDirectiveStepRequest, UpdateGoalRequest, CreateDirectiveOrderGroupRequest, DirectiveOrderGroup, DirectiveOrderGroupListResponse, UpdateDirectiveOrderGroupRequest, @@ -2194,3 +2195,163 @@ pub async fn list_directive_revisions( } } } + +// ============================================================================= +// Ephemeral tasks under a directive +// +// A directive can spin up ad-hoc one-off tasks that are NOT part of its DAG. +// They live in the `tasks` table with `directive_id` set and +// `directive_step_id = NULL` — the existing schema already supports this; we +// just expose the create path through a directive-scoped endpoint and +// inherit repo/branch from the parent directive when the caller doesn't +// override. +// ============================================================================= + +/// Request body for creating an ephemeral task under a directive. +#[derive(Debug, serde::Deserialize, ToSchema)] +#[serde(rename_all = "camelCase")] +pub struct CreateDirectiveTaskRequest { + /// Human-readable name (used for branch/commit names). + pub name: String, + /// Plan / instructions for the Claude Code session. + pub plan: String, + /// Optional override for the directive's repository. + pub repository_url: Option, + /// Optional override for the directive's base branch. + pub base_branch: Option, +} + +/// List the ephemeral tasks (no directive_step_id) attached to a directive. +#[utoipa::path( + get, + path = "/api/v1/directives/{id}/tasks", + params(("id" = Uuid, Path, description = "Directive ID")), + responses( + (status = 200, description = "List of ephemeral tasks", body = crate::db::models::TaskListResponse), + (status = 503, description = "Database not configured", body = ApiError), + ), + security(("bearer_auth" = []), ("api_key" = [])), + tag = "Directives" +)] +pub async fn list_directive_tasks( + State(state): State, + Authenticated(auth): Authenticated, + Path(id): Path, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + match repository::list_ephemeral_directive_tasks_for_owner(pool, auth.owner_id, id).await { + Ok(tasks) => { + let total = tasks.len() as i64; + Json(crate::db::models::TaskListResponse { tasks, total }).into_response() + } + Err(e) => { + tracing::error!("Failed to list ephemeral tasks: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("LIST_FAILED", &e.to_string())), + ) + .into_response() + } + } +} + +/// Create an ephemeral task attached to a directive. +#[utoipa::path( + post, + path = "/api/v1/directives/{id}/tasks", + params(("id" = Uuid, Path, description = "Directive ID")), + request_body = CreateDirectiveTaskRequest, + responses( + (status = 201, description = "Ephemeral task created", body = Task), + (status = 404, description = "Directive not found", body = ApiError), + (status = 503, description = "Database not configured", body = ApiError), + ), + security(("bearer_auth" = []), ("api_key" = [])), + tag = "Directives" +)] +pub async fn create_directive_task( + State(state): State, + Authenticated(auth): Authenticated, + Path(id): Path, + Json(req): Json, +) -> impl IntoResponse { + let Some(ref pool) = state.db_pool else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + + // Look up the parent directive so we can inherit its repository/base branch + // when the caller doesn't override them. Also gates the request on + // ownership: if the directive isn't visible to this owner, 404. + let directive = match repository::get_directive_for_owner(pool, auth.owner_id, id).await { + Ok(Some(d)) => d, + Ok(None) => { + return ( + StatusCode::NOT_FOUND, + Json(ApiError::new("NOT_FOUND", "Directive not found")), + ) + .into_response(); + } + Err(e) => { + tracing::error!("Failed to load directive for ephemeral task: {}", e); + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("DB_ERROR", &e.to_string())), + ) + .into_response(); + } + }; + + let repo_url = req + .repository_url + .or_else(|| directive.repository_url.clone()); + let base_branch = req.base_branch.or_else(|| directive.base_branch.clone()); + + let create_req = CreateTaskRequest { + contract_id: None, + name: req.name, + description: None, + plan: req.plan, + parent_task_id: None, + is_supervisor: false, + priority: 0, + repository_url: repo_url, + base_branch, + target_branch: None, + merge_mode: None, + target_repo_path: None, + completion_action: None, + continue_from_task_id: None, + copy_files: None, + checkpoint_sha: None, + branched_from_task_id: None, + conversation_history: None, + supervisor_worktree_task_id: None, + directive_id: Some(directive.id), + // No directive_step_id — this is what makes the task "ephemeral": + // it lives under the directive folder but isn't part of the DAG. + directive_step_id: None, + }; + + match repository::create_task_for_owner(pool, auth.owner_id, create_req).await { + Ok(task) => (StatusCode::CREATED, Json(task)).into_response(), + Err(e) => { + tracing::error!("Failed to create ephemeral directive task: {}", e); + ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(ApiError::new("CREATE_FAILED", &e.to_string())), + ) + .into_response() + } + } +} diff --git a/makima/src/server/handlers/mesh.rs b/makima/src/server/handlers/mesh.rs index 1a5b9c1..ac5652a 100644 --- a/makima/src/server/handlers/mesh.rs +++ b/makima/src/server/handlers/mesh.rs @@ -78,10 +78,24 @@ pub fn extract_auth(state: &SharedState, headers: &HeaderMap) -> AuthSource { // Task Handlers // ============================================================================= -/// List all tasks for the current owner. +/// Query parameters for `list_tasks`. Currently only the `orphan` filter — +/// when set, returns tasks with NO parent_task_id AND NO directive_id, used +/// by the document-mode sidebar's `tmp/` folder. +#[derive(Debug, serde::Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ListTasksQuery { + #[serde(default)] + pub orphan: bool, +} + +/// List all tasks for the current owner. Pass `?orphan=true` to restrict to +/// top-level tasks with no directive attachment. #[utoipa::path( get, path = "/api/v1/mesh/tasks", + params( + ("orphan" = Option, Query, description = "Filter to tasks with no directive_id and no parent_task_id"), + ), responses( (status = 200, description = "List of tasks", body = TaskListResponse), (status = 401, description = "Unauthorized", body = ApiError), @@ -97,6 +111,7 @@ pub fn extract_auth(state: &SharedState, headers: &HeaderMap) -> AuthSource { pub async fn list_tasks( State(state): State, Authenticated(auth): Authenticated, + axum::extract::Query(query): axum::extract::Query, ) -> impl IntoResponse { let Some(ref pool) = state.db_pool else { return ( @@ -106,7 +121,13 @@ pub async fn list_tasks( .into_response(); }; - match repository::list_tasks_for_owner(pool, auth.owner_id).await { + let result = if query.orphan { + repository::list_orphan_tasks_for_owner(pool, auth.owner_id).await + } else { + repository::list_tasks_for_owner(pool, auth.owner_id).await + }; + + match result { Ok(tasks) => { let total = tasks.len() as i64; Json(TaskListResponse { tasks, total }).into_response() diff --git a/makima/src/server/mod.rs b/makima/src/server/mod.rs index c577904..efae901 100644 --- a/makima/src/server/mod.rs +++ b/makima/src/server/mod.rs @@ -255,6 +255,10 @@ pub fn make_router(state: SharedState) -> Router { .route("/directives/{id}/goal", put(directives::update_goal)) .route("/directives/{id}/revisions", get(directives::list_directive_revisions)) .route("/directives/{id}/new-draft", post(directives::new_directive_draft)) + .route( + "/directives/{id}/tasks", + get(directives::list_directive_tasks).post(directives::create_directive_task), + ) .route("/directives/{id}/cleanup", post(directives::cleanup_directive)) .route("/directives/{id}/create-pr", post(directives::create_pr)) .route("/directives/{id}/pick-up-orders", post(directives::pick_up_orders)) diff --git a/makima/src/server/openapi.rs b/makima/src/server/openapi.rs index e6d4547..7a4b004 100644 --- a/makima/src/server/openapi.rs +++ b/makima/src/server/openapi.rs @@ -132,6 +132,8 @@ use crate::server::messages::{ApiError, AudioEncoding, StartMessage, StopMessage directives::update_goal, directives::list_directive_revisions, directives::new_directive_draft, + directives::create_directive_task, + directives::list_directive_tasks, directives::cleanup_directive, directives::create_pr, // Order endpoints @@ -237,6 +239,7 @@ use crate::server::messages::{ApiError, AudioEncoding, StartMessage, StopMessage DirectiveListResponse, DirectiveRevision, crate::server::handlers::directives::DirectiveRevisionListResponse, + crate::server::handlers::directives::CreateDirectiveTaskRequest, CreateDirectiveRequest, UpdateDirectiveRequest, UpdateGoalRequest, -- cgit v1.2.3