Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

12.1 KB
Raw Blame
//! The summary row in Postgres: `agent_session_changes`, one per session.

use agent_session::domain::model::AgentSessionId;
use chrono::{DateTime, Utc};
use macro_uuid::Uuid;
use sqlx::PgPool;

use crate::domain::model::{
    AttemptOutcome, CaptureAttempt, CapturedBranch, ChangedFile, Changeset, ChangesetId,
    ChangesetRange, ChangesetSource, GitRef, SessionChanges,
};
use crate::domain::ports::{
    ChangesetRepo, PatchBlobKey, PatchLocation, SessionBranchReader, SessionBranchesFuture,
};

#[cfg(test)]
mod test;

/// Postgres-backed [`ChangesetRepo`].
#[derive(Clone)]
pub struct PgChangesetRepo {
    pool: PgPool,
}

impl PgChangesetRepo {
    /// Read and write summaries through `pool`.
    #[must_use]
    pub fn new(pool: PgPool) -> Self {
        Self { pool }
    }
}

impl SessionBranchReader for PgChangesetRepo {
    fn working_branches<'a>(&'a self, sessions: &'a [AgentSessionId]) -> SessionBranchesFuture<'a> {
        Box::pin(async move {
            if sessions.is_empty() {
                return Ok(std::collections::HashMap::new());
            }
            let ids: Vec<_> = sessions.iter().map(AgentSessionId::as_uuid).collect();
            let rows = sqlx::query!(
                r#"
                SELECT agent_session_id, head_ref AS "head_ref!", repository AS "repository!"
                FROM agent_session_changes
                WHERE agent_session_id = ANY($1) AND head_ref IS NOT NULL AND repository IS NOT NULL
                "#,
                &ids,
            )
            .fetch_all(&self.pool)
            .await
            .map_err(|error| rootcause::report!(error))?;
            Ok(rows
                .into_iter()
                .map(|row| {
                    (
                        AgentSessionId::new_from_uuid(row.agent_session_id),
                        CapturedBranch {
                            repository_url: row.repository,
                            branch: row.head_ref,
                        },
                    )
                })
                .collect())
        })
    }
}

/// The row as stored. Kept apart from the domain types so a column rename
/// touches one mapping.
struct ChangesRow {
    changeset_id: Option<Uuid>,
    source: Option<String>,
    repository: Option<String>,
    base_ref: Option<String>,
    base_sha: Option<String>,
    head_ref: Option<String>,
    head_sha: Option<String>,
    files: serde_json::Value,
    additions: i32,
    deletions: i32,
    patch_bytes: i64,
    truncated: bool,
    captured_at: Option<DateTime<Utc>>,
    attempt_started_at: DateTime<Utc>,
    attempt_finished_at: Option<DateTime<Utc>>,
    attempt_outcome: Option<String>,
    attempt_error: Option<String>,
}

impl ChangesRow {
    fn into_changes(self, session: AgentSessionId) -> Result<SessionChanges, rootcause::Report> {
        let attempt = Some(CaptureAttempt {
            started_at: self.attempt_started_at,
            finished_at: self.attempt_finished_at,
            outcome: self
                .attempt_outcome
                .as_deref()
                .map(str::parse::<AttemptOutcome>)
                .transpose()
                .map_err(|error| rootcause::report!("stored attempt outcome: {error}"))?,
            error: self.attempt_error,
        });
        let changeset = match (self.changeset_id, self.source, self.captured_at) {
            (Some(id), Some(source), Some(captured_at)) => {
                let files: Vec<ChangedFile> = serde_json::from_value(self.files)
                    .map_err(|error| rootcause::report!("stored changed files: {error}"))?;
                Some(Changeset {
                    id: ChangesetId::from_uuid(id),
                    session,
                    source: source
                        .parse::<ChangesetSource>()
                        .map_err(|error| rootcause::report!("stored changeset source: {error}"))?,
                    range: ChangesetRange {
                        repository: self.repository,
                        base: GitRef {
                            name: self.base_ref,
                            sha: self.base_sha,
                        },
                        head: GitRef {
                            name: self.head_ref,
                            sha: self.head_sha,
                        },
                    },
                    files,
                    additions: u32::try_from(self.additions).unwrap_or(u32::MAX),
                    deletions: u32::try_from(self.deletions).unwrap_or(u32::MAX),
                    patch_bytes: u64::try_from(self.patch_bytes).unwrap_or(0),
                    truncated: self.truncated,
                    captured_at,
                })
            }
            _ => None,
        };
        Ok(SessionChanges { changeset, attempt })
    }
}

impl ChangesetRepo for PgChangesetRepo {
    #[tracing::instrument(skip(self), err, fields(agent.session.id = %session))]
    async fn begin_attempt(
        &self,
        session: AgentSessionId,
        started_at: DateTime<Utc>,
    ) -> Result<(), rootcause::Report> {
        sqlx::query!(
            r#"
            INSERT INTO agent_session_changes (agent_session_id, attempt_started_at)
            VALUES ($1, $2)
            ON CONFLICT (agent_session_id) DO UPDATE SET
                attempt_started_at = EXCLUDED.attempt_started_at,
                attempt_finished_at = NULL,
                attempt_outcome = NULL,
                attempt_error = NULL,
                updated_at = now()
            "#,
            session.as_uuid(),
            started_at,
        )
        .execute(&self.pool)
        .await
        .map_err(|error| rootcause::report!(error))?;
        Ok(())
    }

    #[tracing::instrument(
        skip(self, changeset, patch),
        err,
        fields(agent.session.id = %changeset.session, changeset.id = %changeset.id)
    )]
    async fn record_changeset(
        &self,
        changeset: &Changeset,
        patch: Option<&PatchLocation>,
        finished_at: DateTime<Utc>,
    ) -> Result<Option<PatchBlobKey>, rootcause::Report> {
        let files = serde_json::to_value(&changeset.files)
            .map_err(|error| rootcause::report!("serialize changed files: {error}"))?;
        let (patch_blob_key, pull_request_changeset_id) = match patch {
            Some(PatchLocation::Blob(key)) => (Some(key.as_str()), None),
            Some(PatchLocation::PullRequest(id)) => (None, Some(*id)),
            None => (None, None),
        };
        // The CTE reads the row as it was before this statement, which is
        // what makes "the key this capture superseded" one round trip.
        let superseded = sqlx::query_scalar!(
            r#"
            WITH previous AS (
                SELECT patch_blob_key FROM agent_session_changes WHERE agent_session_id = $1
            )
            INSERT INTO agent_session_changes (
                agent_session_id, changeset_id, source, repository,
                base_ref, base_sha, head_ref, head_sha,
                files, additions, deletions, patch_blob_key, pull_request_changeset_id,
                patch_bytes, truncated,
                captured_at, attempt_started_at, attempt_finished_at, attempt_outcome, attempt_error
            )
            VALUES (
                $1, $2, $3, $4,
                $5, $6, $7, $8,
                $9, $10, $11, $12, $17,
                $13, $14,
                $15, $16, $16, 'captured', NULL
            )
            ON CONFLICT (agent_session_id) DO UPDATE SET
                changeset_id = EXCLUDED.changeset_id,
                source = EXCLUDED.source,
                repository = EXCLUDED.repository,
                base_ref = EXCLUDED.base_ref,
                base_sha = EXCLUDED.base_sha,
                head_ref = EXCLUDED.head_ref,
                head_sha = EXCLUDED.head_sha,
                files = EXCLUDED.files,
                additions = EXCLUDED.additions,
                deletions = EXCLUDED.deletions,
                patch_blob_key = EXCLUDED.patch_blob_key,
                pull_request_changeset_id = EXCLUDED.pull_request_changeset_id,
                patch_bytes = EXCLUDED.patch_bytes,
                truncated = EXCLUDED.truncated,
                captured_at = EXCLUDED.captured_at,
                attempt_finished_at = EXCLUDED.attempt_finished_at,
                attempt_outcome = 'captured',
                attempt_error = NULL,
                updated_at = now()
            RETURNING (SELECT patch_blob_key FROM previous) AS "superseded?"
            "#,
            changeset.session.as_uuid(),
            changeset.id.as_uuid(),
            changeset.source.to_string(),
            changeset.range.repository.as_deref(),
            changeset.range.base.name.as_deref(),
            changeset.range.base.sha.as_deref(),
            changeset.range.head.name.as_deref(),
            changeset.range.head.sha.as_deref(),
            files,
            i32::try_from(changeset.additions).unwrap_or(i32::MAX),
            i32::try_from(changeset.deletions).unwrap_or(i32::MAX),
            patch_blob_key,
            i64::try_from(changeset.patch_bytes).unwrap_or(i64::MAX),
            changeset.truncated,
            changeset.captured_at,
            finished_at,
            pull_request_changeset_id,
        )
        .fetch_one(&self.pool)
        .await
        .map_err(|error| rootcause::report!(error))?;
        Ok(superseded.map(PatchBlobKey::from_stored))
    }

    #[tracing::instrument(skip(self, error), err, fields(agent.session.id = %session, %outcome))]
    async fn record_failure(
        &self,
        session: AgentSessionId,
        outcome: AttemptOutcome,
        error: Option<&str>,
        finished_at: DateTime<Utc>,
    ) -> Result<(), rootcause::Report> {
        sqlx::query!(
            r#"
            INSERT INTO agent_session_changes (
                agent_session_id, attempt_started_at, attempt_finished_at, attempt_outcome, attempt_error
            )
            VALUES ($1, $4, $4, $2, $3)
            ON CONFLICT (agent_session_id) DO UPDATE SET
                attempt_finished_at = EXCLUDED.attempt_finished_at,
                attempt_outcome = EXCLUDED.attempt_outcome,
                attempt_error = EXCLUDED.attempt_error,
                updated_at = now()
            "#,
            session.as_uuid(),
            outcome.to_string(),
            error,
            finished_at,
        )
        .execute(&self.pool)
        .await
        .map_err(|error| rootcause::report!(error))?;
        Ok(())
    }

    #[tracing::instrument(skip(self), err, fields(agent.session.id = %session))]
    async fn get(&self, session: AgentSessionId) -> Result<SessionChanges, rootcause::Report> {
        let row = sqlx::query_as!(
            ChangesRow,
            r#"
            SELECT changeset_id, source, repository, base_ref, base_sha, head_ref, head_sha,
                   files, additions, deletions, patch_bytes, truncated, captured_at,
                   attempt_started_at, attempt_finished_at, attempt_outcome, attempt_error
            FROM agent_session_changes
            WHERE agent_session_id = $1
            "#,
            session.as_uuid(),
        )
        .fetch_optional(&self.pool)
        .await
        .map_err(|error| rootcause::report!(error))?;
        match row {
            Some(row) => row.into_changes(session),
            None => Ok(SessionChanges::default()),
        }
    }

    #[tracing::instrument(skip(self), err, fields(agent.session.id = %session))]
    async fn patch_location(
        &self,
        session: AgentSessionId,
    ) -> Result<Option<PatchLocation>, rootcause::Report> {
        let row = sqlx::query!(
            r#"
            SELECT patch_blob_key, pull_request_changeset_id
            FROM agent_session_changes
            WHERE agent_session_id = $1
            "#,
            session.as_uuid(),
        )
        .fetch_optional(&self.pool)
        .await
        .map_err(|error| rootcause::report!(error))?;
        Ok(row.and_then(
            |row| match (row.patch_blob_key, row.pull_request_changeset_id) {
                (Some(key), _) => Some(PatchLocation::Blob(PatchBlobKey::from_stored(key))),
                (None, Some(id)) => Some(PatchLocation::PullRequest(id)),
                (None, None) => None,
            },
        ))
    }
}