second-brain-api 0.13.1

HTTP API server for second-brain: REST endpoints for recall, remember, and ingest
Documentation
mod common;

use axum::http::StatusCode;
use chrono::{Duration, Utc};
use serde_json::Value;
use tower::ServiceExt;

use common::{app_with_store, get, json_body};
use second_brain_core::schema::{AGENT_NOTE_SOURCE, Memory};
use second_brain_core::sqlite_store::{AgentNote, NoteKind, SqliteStore};
use second_brain_core::store::Store;

async fn digest(app: &axum::Router, query: &str) -> (StatusCode, Value) {
    let response = app
        .clone()
        .oneshot(get(&format!("/v1/digest{query}")))
        .await
        .unwrap();
    let status = response.status();
    (status, json_body(response).await)
}

fn store_note(store: &SqliteStore, session: &str, project: &str, age: Duration, note: AgentNote) {
    let mut memory = Memory::new(
        note.render(),
        note.kind.memory_type(),
        AGENT_NOTE_SOURCE.to_string(),
        session.to_string(),
    )
    .with_project_path(Some(project.to_string()));
    memory.created_at = Utc::now() - age;
    store.store_memory(&memory).unwrap();
}

#[tokio::test]
async fn a_note_in_the_window_comes_back_in_the_digest() {
    let (app, store) = app_with_store();
    let mut note = AgentNote::new(NoteKind::SessionEnd, "keep the build cache per worktree");
    note.reason = "a shared cache mixed crates".to_string();
    note.blocked_on_user = vec!["approve the signing key".to_string()];
    store_note(&store, "s1", "-srv-app", Duration::hours(2), note);
    store_note(
        &store,
        "s0",
        "-srv-app",
        Duration::days(3),
        AgentNote::new(NoteKind::Decision, "an older decision"),
    );

    let (status, body) = digest(&app, "").await;

    assert_eq!(status, StatusCode::OK, "{body}");
    let projects = body["projects"].as_array().unwrap();
    assert_eq!(projects.len(), 1, "{body}");
    let app_digest = &projects[0];
    assert_eq!(app_digest["project"], "-srv-app");
    assert_eq!(app_digest["noted_sessions"], 1);
    let decided = app_digest["decided"]["items"].as_array().unwrap();
    assert_eq!(decided.len(), 1, "{body}");
    assert_eq!(decided[0]["text"], "keep the build cache per worktree");
    assert_eq!(decided[0]["reason"], "a shared cache mixed crates");
    assert_eq!(
        app_digest["blocked_on_user"]["items"][0]["text"],
        "approve the signing key"
    );
    assert!(body["project"].is_null(), "{body}");
}

#[tokio::test]
async fn since_widens_the_window() {
    let (app, store) = app_with_store();
    store_note(
        &store,
        "s0",
        "-srv-app",
        Duration::days(3),
        AgentNote::new(NoteKind::Decision, "an older decision"),
    );

    let (status, body) = digest(&app, "?since=7d").await;

    assert_eq!(status, StatusCode::OK, "{body}");
    assert_eq!(
        body["projects"][0]["decided"]["items"][0]["text"], "an older decision",
        "{body}"
    );
}

#[tokio::test]
async fn a_project_filter_keeps_one_project() {
    let (app, store) = app_with_store();
    for (session, project) in [("s1", "-srv-app"), ("s2", "-srv-web")] {
        store_note(
            &store,
            session,
            project,
            Duration::hours(1),
            AgentNote::new(NoteKind::Decision, format!("decided in {project}")),
        );
    }

    let (status, body) = digest(&app, "?project=-srv-web").await;

    assert_eq!(status, StatusCode::OK, "{body}");
    assert_eq!(body["project"], "-srv-web");
    let projects = body["projects"].as_array().unwrap();
    assert_eq!(projects.len(), 1, "{body}");
    assert_eq!(projects[0]["project"], "-srv-web");
}

#[tokio::test]
async fn a_bad_since_is_a_400_with_the_parse_message() {
    let (app, _) = app_with_store();

    let (status, body) = digest(&app, "?since=24x").await;

    assert_eq!(status, StatusCode::BAD_REQUEST, "{body}");
    assert!(
        body["error"]
            .as_str()
            .unwrap()
            .contains("invalid window '24x'"),
        "{body}"
    );
}

#[tokio::test]
async fn a_project_nothing_is_stored_under_is_a_400_listing_near_names() {
    let (app, store) = app_with_store();
    store_note(
        &store,
        "s1",
        "-srv-garden",
        Duration::hours(1),
        AgentNote::new(NoteKind::Decision, "water on tuesdays"),
    );

    let (status, body) = digest(&app, "?project=gardn").await;

    assert_eq!(status, StatusCode::BAD_REQUEST, "{body}");
    let error = body["error"].as_str().unwrap();
    assert!(error.contains("\"gardn\""), "{error}");
    assert!(error.contains("near names: -srv-garden"), "{error}");
}

#[tokio::test]
async fn no_notes_give_an_empty_project_list() {
    let (app, _) = app_with_store();

    let (status, body) = digest(&app, "").await;

    assert_eq!(status, StatusCode::OK, "{body}");
    assert_eq!(body["projects"], serde_json::json!([]), "{body}");
    assert!(body["window"]["since"].is_string(), "{body}");
    assert!(body["window"]["until"].is_string(), "{body}");
}