gitcell 0.1.0

Local-first, multi-client git companion server: git ops, agent prompt history, and Action-style workflows.
Documentation
use std::sync::Arc;

use axum::{
    body::Body,
    http::{Request, StatusCode},
};
use cellz::cell::CellManager;
use cellz::storage::LocalBlobStore;
use gitcell::server::{self, AppState};
use http_body_util::BodyExt;
use tower::ServiceExt;

async fn test_state() -> (AppState, tempfile::TempDir) {
    let tmp = tempfile::tempdir().unwrap();
    let cells_dir = tmp.path().join("cells");
    let cells_storage_dir = tmp.path().join("cells-storage");
    let data_dir = tmp.path().join("repos");
    std::fs::create_dir_all(&cells_dir).unwrap();
    std::fs::create_dir_all(&cells_storage_dir).unwrap();
    std::fs::create_dir_all(&data_dir).unwrap();

    let blob_store = Arc::new(LocalBlobStore::new(&cells_storage_dir));
    let cell_manager = Arc::new(CellManager::new(&cells_dir, blob_store, 60));

    let state = AppState {
        cell_manager,
        data_dir,
    };
    (state, tmp)
}

#[tokio::test]
async fn test_health_check() {
    let (state, _tmp) = test_state().await;
    let app = server::create_router(state);

    let response = app
        .oneshot(
            Request::builder()
                .uri("/health")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();

    assert_eq!(response.status(), StatusCode::OK);

    let body = response.into_body().collect().await.unwrap().to_bytes();
    let json: serde_json::Value = serde_json::from_slice(&body).unwrap();

    assert_eq!(json["status"], "ok");
    assert_eq!(json["service"], "gitcell");
}

#[tokio::test]
async fn test_repo_init_and_status() {
    let (state, _tmp) = test_state().await;
    let app = server::create_router(state);

    let response = app
        .clone()
        .oneshot(
            Request::builder()
                .method("POST")
                .uri("/api/v1/repos/demo/init")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(response.status(), StatusCode::OK);

    let response = app
        .oneshot(
            Request::builder()
                .uri("/api/v1/repos/demo/status")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(response.status(), StatusCode::OK);
}

#[tokio::test]
async fn test_repo_status_missing_repo_is_not_found() {
    let (state, _tmp) = test_state().await;
    let app = server::create_router(state);

    let response = app
        .oneshot(
            Request::builder()
                .uri("/api/v1/repos/does-not-exist/status")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(response.status(), StatusCode::NOT_FOUND);
}

#[tokio::test]
async fn test_invalid_repo_name_is_rejected() {
    let (state, _tmp) = test_state().await;
    let app = server::create_router(state);

    let response = app
        .oneshot(
            Request::builder()
                .uri("/api/v1/repos/..%2f..%2fetc/status")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}

#[tokio::test]
async fn test_prompts_record_and_list() {
    let (state, _tmp) = test_state().await;
    let app = server::create_router(state);

    let response = app
        .clone()
        .oneshot(
            Request::builder()
                .method("POST")
                .uri("/api/v1/repos/demo/prompts")
                .header("content-type", "application/json")
                .body(Body::from(
                    serde_json::json!({"role": "user", "content": "hello"}).to_string(),
                ))
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(response.status(), StatusCode::OK);

    let response = app
        .oneshot(
            Request::builder()
                .uri("/api/v1/repos/demo/prompts")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(response.status(), StatusCode::OK);
    let body = response.into_body().collect().await.unwrap().to_bytes();
    let json: serde_json::Value = serde_json::from_slice(&body).unwrap();
    assert_eq!(json.as_array().unwrap().len(), 1);
    assert_eq!(json[0]["content"], "hello");
}

#[tokio::test]
async fn test_workflows_list_empty_when_missing() {
    let (state, _tmp) = test_state().await;
    let app = server::create_router(state);

    let response = app
        .oneshot(
            Request::builder()
                .uri("/api/v1/repos/demo/workflows")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(response.status(), StatusCode::OK);
    let body = response.into_body().collect().await.unwrap().to_bytes();
    let json: serde_json::Value = serde_json::from_slice(&body).unwrap();
    assert_eq!(json.as_array().unwrap().len(), 0);
}

async fn json_request(
    app: axum::Router,
    method: &str,
    uri: &str,
    body: Option<serde_json::Value>,
) -> (StatusCode, serde_json::Value) {
    let mut builder = Request::builder().method(method).uri(uri);
    let body = if let Some(payload) = body {
        builder = builder.header("content-type", "application/json");
        Body::from(payload.to_string())
    } else {
        Body::empty()
    };
    let response = app.oneshot(builder.body(body).unwrap()).await.unwrap();
    let status = response.status();
    let bytes = response.into_body().collect().await.unwrap().to_bytes();
    let json = if bytes.is_empty() {
        serde_json::Value::Null
    } else {
        serde_json::from_slice(&bytes).unwrap_or(serde_json::Value::Null)
    };
    (status, json)
}

#[tokio::test]
async fn personal_loop_init_commit_workflow_prompt_log() {
    let (state, tmp) = test_state().await;
    let data_dir = state.data_dir.clone();
    let app = server::create_router(state);

    let (status, _) = json_request(app.clone(), "POST", "/api/v1/repos/demo/init", None).await;
    assert_eq!(status, StatusCode::OK);

    let repo = data_dir.join("demo");
    std::fs::write(repo.join("README.md"), "hello gitcell\n").unwrap();
    let wf_dir = repo.join(".gitcell/workflows");
    std::fs::create_dir_all(&wf_dir).unwrap();
    std::fs::write(
        wf_dir.join("ci.yml"),
        "name: CI\non: [push]\njobs:\n  build:\n    steps:\n      - name: ok\n        run: echo ci-ok\n",
    )
    .unwrap();

    let (status, commit) = json_request(
        app.clone(),
        "POST",
        "/api/v1/repos/demo/commit",
        Some(serde_json::json!({"message": "initial commit"})),
    )
    .await;
    assert_eq!(status, StatusCode::OK, "commit failed: {commit}");
    let sha = commit["sha"].as_str().unwrap().to_string();
    assert!(!sha.is_empty());
    assert_eq!(commit["branch"], "main");
    assert_eq!(commit["workflows"][0]["name"], "CI");
    assert_eq!(
        commit["workflows"][0]["jobs"][0]["steps"][0]["success"],
        true
    );

    let (status, prompt) = json_request(
        app.clone(),
        "POST",
        "/api/v1/repos/demo/prompts",
        Some(serde_json::json!({
            "role": "user",
            "content": "add a readme"
        })),
    )
    .await;
    assert_eq!(status, StatusCode::OK);
    assert_eq!(prompt["content"], "add a readme");
    assert_eq!(prompt["commit"], sha);
    assert_eq!(prompt["branch"], "main");

    let (status, listed) = json_request(
        app.clone(),
        "GET",
        &format!("/api/v1/repos/demo/prompts?commit={sha}"),
        None,
    )
    .await;
    assert_eq!(status, StatusCode::OK);
    assert_eq!(listed.as_array().unwrap().len(), 1);

    let (status, log) = json_request(app.clone(), "GET", "/api/v1/repos/demo/log", None).await;
    assert_eq!(status, StatusCode::OK);
    assert!(log["log"].as_str().unwrap().contains("initial commit"));

    let (status, repos) = json_request(app.clone(), "GET", "/api/v1/repos", None).await;
    assert_eq!(status, StatusCode::OK);
    assert_eq!(repos["repos"], serde_json::json!(["demo"]));

    let (status, _) = json_request(
        app.clone(),
        "PUT",
        "/api/v1/repos/demo/files/src/hello.txt",
        Some(serde_json::json!({"content": "from api\n"})),
    )
    .await;
    assert_eq!(status, StatusCode::OK);
    let (status, file) = json_request(
        app.clone(),
        "GET",
        "/api/v1/repos/demo/files/src/hello.txt",
        None,
    )
    .await;
    assert_eq!(status, StatusCode::OK);
    assert_eq!(file["content"], "from api\n");
    let (status, tree) = json_request(app.clone(), "GET", "/api/v1/repos/demo/tree", None).await;
    assert_eq!(status, StatusCode::OK);
    let tree = tree["tree"].as_array().unwrap();
    assert!(tree.iter().any(|e| e["path"] == "src/hello.txt"));

    let (status, _) = json_request(
        app.clone(),
        "GET",
        "/api/v1/repos/demo/files/.git/config",
        None,
    )
    .await;
    assert_eq!(status, StatusCode::BAD_REQUEST);

    let (status, _) = json_request(
        app.clone(),
        "POST",
        "/api/v1/repos/demo/branches",
        Some(serde_json::json!({"name": "feat-x", "checkout": true})),
    )
    .await;
    assert_eq!(status, StatusCode::OK);
    let (status, branches) =
        json_request(app.clone(), "GET", "/api/v1/repos/demo/branches", None).await;
    assert_eq!(status, StatusCode::OK);
    assert_eq!(branches["current"], "feat-x");

    let _ = tmp;
}