Apply AI object and context fixes

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "git-internal"
-version = "0.5.0"
+version = "0.6.0"
 edition = "2024"
 license = "MIT"
 description = "Git-Internal is a high-performance Rust library for encoding and decoding Git internal objects and Pack files."

src/errors.rs

@@ -90,6 +90,10 @@ pub enum GitError {
     #[error("Not a valid agent task object: {0}")]
     InvalidTaskObject(String),
 
+    /// Malformed intent object.
+    #[error("Not a valid agent intent object: {0}")]
+    InvalidIntentObject(String),
+
     /// Malformed tool invocation object.
     #[error("Not a valid agent tool invocation object: {0}")]
     InvalidToolInvocationObject(String),

src/internal/object/blob.rs

@@ -105,7 +105,10 @@ impl Blob {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::hash::{HashKind, set_hash_kind_for_test};
+    use crate::{
+        hash::{HashKind, set_hash_kind_for_test},
+        internal::object::ObjectTrait,
+    };
 
     /// Test creating a Blob from content string
     #[test]
@@ -117,6 +120,8 @@ mod tests {
             blob.id.to_string(),
             "5dd01c177f5d7d1be5346a5bc18a569a7410c2ef"
         );
+        let hash_from_trait = blob.object_hash().unwrap();
+        assert_eq!(hash_from_trait.to_string(), blob.id.to_string());
     }
 
     /// Test creating a Blob from content string using SHA-256 hash algorithm.

src/internal/object/context.rs

@@ -44,6 +44,15 @@ pub enum SelectionStrategy {
 pub enum ContextItemKind {
     /// A regular file in the repository.
     File,
+    /// A URL (web page, API endpoint, etc.).
+    Url,
+    /// A free-form text snippet (e.g. doc fragment, note).
+    Snippet,
+    /// Command or terminal output.
+    Command,
+    /// Image or other binary visual content.
+    Image,
+    Other(String),
 }
 
 /// Context item describing a single input.
@@ -52,6 +61,11 @@ pub struct ContextItem {
     pub kind: ContextItemKind,
     pub path: String,
     pub content_id: IntegrityHash,
+    /// Optional preview/summary of the content (for example, first 200 characters).
+    /// Used for display without loading the full content via `content_id`.
+    /// Should be kept under 500 characters for performance.
+    #[serde(default)]
+    pub content_preview: Option<String>,
 }
 
 impl ContextItem {
@@ -68,6 +82,7 @@ impl ContextItem {
             kind,
             path,
             content_id,
+            content_preview: None,
         })
     }
 }
@@ -150,7 +165,13 @@ impl ObjectTrait for ContextSnapshot {
     }
 
     fn get_size(&self) -> usize {
-        serde_json::to_vec(self).map(|v| v.len()).unwrap_or(0)
+        match serde_json::to_vec(self) {
+            Ok(v) => v.len(),
+            Err(e) => {
+                tracing::warn!("failed to compute ContextSnapshot size: {}", e);
+                0
+            }
+        }
     }
 
     fn to_data(&self) -> Result<Vec<u8>, GitError> {

src/internal/object/decision.rs

@@ -180,7 +180,13 @@ impl ObjectTrait for Decision {
     }
 
     fn get_size(&self) -> usize {
-        serde_json::to_vec(self).map(|v| v.len()).unwrap_or(0)
+        match serde_json::to_vec(self) {
+            Ok(v) => v.len(),
+            Err(e) => {
+                tracing::warn!("failed to compute Decision size: {}", e);
+                0
+            }
+        }
     }
 
     fn to_data(&self) -> Result<Vec<u8>, GitError> {

src/internal/object/evidence.rs

@@ -184,7 +184,13 @@ impl ObjectTrait for Evidence {
     }
 
     fn get_size(&self) -> usize {
-        serde_json::to_vec(self).map(|v| v.len()).unwrap_or(0)
+        match serde_json::to_vec(self) {
+            Ok(v) => v.len(),
+            Err(e) => {
+                tracing::warn!("failed to compute Evidence size: {}", e);
+                0
+            }
+        }
     }
 
     fn to_data(&self) -> Result<Vec<u8>, GitError> {

src/internal/object/intent.rs

@@ -0,0 +1,169 @@
+use std::fmt;
+
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use crate::{
+    errors::GitError,
+    hash::ObjectHash,
+    internal::object::{
+        ObjectTrait,
+        integrity::IntegrityHash,
+        types::{ActorRef, Header, ObjectType},
+    },
+};
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum IntentStatus {
+    Draft,
+    Active,
+    Completed,
+    Cancelled,
+}
+
+impl IntentStatus {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            IntentStatus::Draft => "draft",
+            IntentStatus::Active => "active",
+            IntentStatus::Completed => "completed",
+            IntentStatus::Cancelled => "cancelled",
+        }
+    }
+}
+
+impl fmt::Display for IntentStatus {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Intent {
+    #[serde(flatten)]
+    header: Header,
+    content: String,
+    parent_id: Option<Uuid>,
+    root_id: Option<Uuid>,
+    task_id: Option<Uuid>,
+    result_commit_sha: Option<IntegrityHash>,
+    status: IntentStatus,
+}
+
+impl Intent {
+    pub fn new(
+        repo_id: Uuid,
+        created_by: ActorRef,
+        content: impl Into<String>,
+    ) -> Result<Self, String> {
+        Ok(Self {
+            header: Header::new(ObjectType::Intent, repo_id, created_by)?,
+            content: content.into(),
+            parent_id: None,
+            root_id: None,
+            task_id: None,
+            result_commit_sha: None,
+            status: IntentStatus::Draft,
+        })
+    }
+
+    pub fn header(&self) -> &Header {
+        &self.header
+    }
+
+    pub fn content(&self) -> &str {
+        &self.content
+    }
+
+    pub fn parent_id(&self) -> Option<Uuid> {
+        self.parent_id
+    }
+
+    pub fn root_id(&self) -> Option<Uuid> {
+        self.root_id
+    }
+
+    pub fn task_id(&self) -> Option<Uuid> {
+        self.task_id
+    }
+
+    pub fn result_commit_sha(&self) -> Option<&IntegrityHash> {
+        self.result_commit_sha.as_ref()
+    }
+
+    pub fn status(&self) -> &IntentStatus {
+        &self.status
+    }
+
+    pub fn set_parent_id(&mut self, parent_id: Option<Uuid>) {
+        self.parent_id = parent_id;
+    }
+
+    pub fn set_root_id(&mut self, root_id: Option<Uuid>) {
+        self.root_id = root_id;
+    }
+
+    pub fn set_task_id(&mut self, task_id: Option<Uuid>) {
+        self.task_id = task_id;
+    }
+
+    pub fn set_result_commit_sha(&mut self, sha: Option<IntegrityHash>) {
+        self.result_commit_sha = sha;
+    }
+
+    pub fn set_status(&mut self, status: IntentStatus) {
+        self.status = status;
+    }
+}
+
+impl fmt::Display for Intent {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Intent: {}", self.header.object_id())
+    }
+}
+
+impl ObjectTrait for Intent {
+    fn from_bytes(data: &[u8], _hash: ObjectHash) -> Result<Self, GitError>
+    where
+        Self: Sized,
+    {
+        serde_json::from_slice(data).map_err(|e| GitError::InvalidIntentObject(e.to_string()))
+    }
+
+    fn get_type(&self) -> ObjectType {
+        ObjectType::Intent
+    }
+
+    fn get_size(&self) -> usize {
+        match serde_json::to_vec(self) {
+            Ok(v) => v.len(),
+            Err(e) => {
+                tracing::warn!("failed to compute Intent size: {}", e);
+                0
+            }
+        }
+    }
+
+    fn to_data(&self) -> Result<Vec<u8>, GitError> {
+        serde_json::to_vec(self).map_err(|e| GitError::InvalidIntentObject(e.to_string()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_intent_creation() {
+        let repo_id = Uuid::from_u128(0x0123456789abcdef0123456789abcdef);
+        let actor = ActorRef::human("jackie").expect("actor");
+        let intent = Intent::new(repo_id, actor, "Refactor login flow").expect("intent");
+
+        assert_eq!(intent.header().object_type(), &ObjectType::Intent);
+        assert_eq!(intent.status(), &IntentStatus::Draft);
+        assert!(intent.parent_id().is_none());
+        assert!(intent.root_id().is_none());
+        assert!(intent.task_id().is_none());
+    }
+}

src/internal/object/mod.rs

@@ -6,6 +6,7 @@ pub mod context;
 pub mod decision;
 pub mod evidence;
 pub mod integrity;
+pub mod intent;
 pub mod note;
 pub mod patchset;
 pub mod plan;
@@ -58,4 +59,13 @@ pub trait ObjectTrait: Send + Sync + Display {
     fn get_size(&self) -> usize;
 
     fn to_data(&self) -> Result<Vec<u8>, GitError>;
+
+    /// Computes the object hash from serialized data.
+    ///
+    /// Default implementation serializes the object and computes the hash from that data.
+    /// Override only if you need custom hash computation or caching.
+    fn object_hash(&self) -> Result<ObjectHash, GitError> {
+        let data = self.to_data()?;
+        Ok(ObjectHash::from_type_and_data(self.get_type(), &data))
+    }
 }