blomios/IdeA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(tickets): création d'un assistant IA de ticket (backend + frontend)

Browse Source 
Ajoute le chat assistant IA attaché à un ticket (#8).

Backend Rust :
- use cases OpenTicketAssistant/CloseTicketAssistant + tests
- politique d'outils par agent (domain/agent_tool_policy) et policy MCP
- store de contexte assistant + gabarit default_ticket_assistant.md + tests
- events TicketAssistantOpened/Closed
- commandes Tauri open_ticket_chat/close_ticket_chat et câblage state/lib/events

Frontend :
- gateway (ports, adapters ticket + mock, domain)
- hook useTicketAssistant + composant TicketAssistantPanel
- intégration dans TicketDetail

Tests verts : vitest tickets.test.tsx (23), cargo test application::ticket_assistant (1),
infrastructure::assistant_context_store (2).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Blomios
2026-07-06 06:06:24 +02:00
parent f1803768fd
commit 1fdf62c089
29 changed files with 2173 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
crates/application/src/lib.rs
View File

@ -30,6 +30,7 @@ pub mod skill;
pub mod sprints;
pub mod template;
pub mod terminal;
pub mod ticket_assistant;
pub mod window;
pub mod workstate;
@ -149,6 +150,10 @@ pub use terminal::{
ResizeTerminal, ResizeTerminalInput, StructuredSessions, TerminalSessions, WriteToTerminal,
WriteToTerminalInput,
};
pub use ticket_assistant::{
CloseTicketAssistant, CloseTicketAssistantInput, OpenTicketAssistant, OpenTicketAssistantInput,
OpenTicketAssistantOutput,
};
pub use window::{MoveTabToNewWindow, MoveTabToNewWindowInput, MoveTabToNewWindowOutput};
pub use workstate::{
AgentBackgroundTaskState, AgentTicketState, AgentWorkState, AttachLiveAgent,

92
crates/application/src/terminal/registry.rs
View File

@ -11,7 +11,7 @@ use std::sync::{Arc, Mutex};
use domain::conversation::ConversationId;
use domain::ports::{AgentSession, PtyHandle};
use domain::{AgentId, NodeId, SessionId, SessionKind, TerminalSession};
use domain::{AgentId, IssueRef, NodeId, SessionId, SessionKind, TerminalSession};
/// Runtime family of a live agent session.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
@ -303,6 +303,12 @@ struct StructuredEntry {
node_id: NodeId,
}
#[derive(Clone)]
struct TicketAssistantEntry {
session: Arc<dyn AgentSession>,
requester: String,
}
/// Registre en mémoire des sessions IA structurées vivantes (ARCHITECTURE §17.5).
///
/// **Jumeau de [`TerminalSessions`]** : même rôle (état d'exécution applicatif, pas
@ -318,6 +324,7 @@ struct StructuredEntry {
#[derive(Default)]
pub struct StructuredSessions {
entries: Mutex<HashMap<SessionId, StructuredEntry>>,
ticket_assistants: Mutex<HashMap<IssueRef, TicketAssistantEntry>>,
}
impl LiveAgentRegistry for StructuredSessions {
@ -339,6 +346,7 @@ impl StructuredSessions {
pub fn new() -> Self {
Self {
entries: Mutex::new(HashMap::new()),
ticket_assistants: Mutex::new(HashMap::new()),
}
}
@ -365,6 +373,60 @@ impl StructuredSessions {
.lock()
.ok()
.and_then(|m| m.get(id).map(|e| Arc::clone(&e.session)))
.or_else(|| {
self.ticket_assistants.lock().ok().and_then(|m| {
m.values()
.find(|e| e.session.id() == *id)
.map(|e| Arc::clone(&e.session))
})
})
}
/// Enregistre une session assistant ticket éphémère, keyée par `issue_ref`.
///
/// Retourne l'éventuelle session remplacée pour que l'appelant puisse la fermer
/// hors verrou. Ces sessions ne sont pas des agents manifest et ne participent
/// donc pas aux vues `live_agents`.
pub fn insert_ticket_assistant(
&self,
issue_ref: IssueRef,
requester: String,
session: Arc<dyn AgentSession>,
) -> Option<Arc<dyn AgentSession>> {
self.ticket_assistants
.lock()
.ok()
.and_then(|mut m| m.insert(issue_ref, TicketAssistantEntry { session, requester }))
.map(|entry| entry.session)
}
/// Retourne la session assistant vivante pour `issue_ref`, si présente.
#[must_use]
pub fn ticket_assistant_session(&self, issue_ref: IssueRef) -> Option<Arc<dyn AgentSession>> {
self.ticket_assistants
.lock()
.ok()
.and_then(|m| m.get(&issue_ref).map(|e| Arc::clone(&e.session)))
}
/// Retourne l'identité MCP requester de l'assistant ticket, si présent.
#[must_use]
pub fn ticket_assistant_requester(&self, issue_ref: IssueRef) -> Option<String> {
self.ticket_assistants
.lock()
.ok()
.and_then(|m| m.get(&issue_ref).map(|e| e.requester.clone()))
}
/// Retire l'assistant ticket pour `issue_ref`.
pub fn remove_ticket_assistant(
&self,
issue_ref: IssueRef,
) -> Option<(Arc<dyn AgentSession>, String)> {
self.ticket_assistants
.lock()
.ok()
.and_then(|mut m| m.remove(&issue_ref).map(|e| (e.session, e.requester)))
}
/// Retourne la session vivante hébergeant `agent_id`, si elle existe.
@ -460,6 +522,15 @@ impl StructuredSessions {
.lock()
.ok()
.and_then(|mut m| m.remove(id).map(|e| e.session))
.or_else(|| {
self.ticket_assistants.lock().ok().and_then(|mut m| {
let issue_ref = m
.iter()
.find(|(_, e)| e.session.id() == *id)
.map(|(issue_ref, _)| *issue_ref)?;
m.remove(&issue_ref).map(|e| e.session)
})
})
}
/// Retourne toutes les sessions vivantes (pour un arrêt global propre au
@ -468,14 +539,31 @@ impl StructuredSessions {
pub fn sessions(&self) -> Vec<Arc<dyn AgentSession>> {
self.entries
.lock()
.map(|m| m.values().map(|e| Arc::clone(&e.session)).collect())
.map(|m| {
m.values()
.map(|e| Arc::clone(&e.session))
.collect::<Vec<_>>()
})
.unwrap_or_default()
.into_iter()
.chain(
self.ticket_assistants
.lock()
.map(|m| {
m.values()
.map(|e| Arc::clone(&e.session))
.collect::<Vec<_>>()
})
.unwrap_or_default(),
)
.collect()
}
/// Nombre de sessions structurées vivantes.
#[must_use]
pub fn len(&self) -> usize {
self.entries.lock().map(|m| m.len()).unwrap_or(0)
+ self.ticket_assistants.lock().map(|m| m.len()).unwrap_or(0)
}
/// Si le registre est vide.

222
crates/application/src/ticket_assistant.rs Normal file
View File

@ -0,0 +1,222 @@
//! Use cases for ephemeral AI ticket editing assistants.
use std::sync::Arc;
use domain::ports::{AgentSessionFactory, SessionPlan};
use domain::{AgentProfile, ProjectPath};
use domain::{
AgentToolPolicy, AgentToolPolicyStore, AssistantContextProvider, DomainEvent, EventBus,
IssueRef, IssueStore, ProfileId, ProfileStore, Project, SandboxPlan, SessionId,
};
use crate::terminal::StructuredSessions;
use crate::AppError;
/// Opens an ephemeral ticket assistant chat session.
pub struct OpenTicketAssistant {
issues: Arc<dyn IssueStore>,
profiles: Arc<dyn ProfileStore>,
contexts: Arc<dyn AssistantContextProvider>,
factory: Arc<dyn AgentSessionFactory>,
structured: Arc<StructuredSessions>,
policies: Arc<dyn AgentToolPolicyStore>,
events: Arc<dyn EventBus>,
}
/// Input for [`OpenTicketAssistant`].
pub struct OpenTicketAssistantInput {
/// Project owning the ticket.
pub project: Project,
/// Ticket reference to bind.
pub issue_ref: IssueRef,
/// Structured profile to use.
pub profile_id: ProfileId,
}
/// Output of [`OpenTicketAssistant`].
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct OpenTicketAssistantOutput {
/// Live structured session id, to be driven by `agent_send`.
pub session_id: SessionId,
/// MCP requester identity bound to this assistant.
pub requester: String,
/// Bound ticket reference.
pub issue_ref: IssueRef,
}
impl OpenTicketAssistant {
/// Builds the use case.
#[allow(clippy::too_many_arguments)]
#[must_use]
pub fn new(
issues: Arc<dyn IssueStore>,
profiles: Arc<dyn ProfileStore>,
contexts: Arc<dyn AssistantContextProvider>,
factory: Arc<dyn AgentSessionFactory>,
structured: Arc<StructuredSessions>,
policies: Arc<dyn AgentToolPolicyStore>,
events: Arc<dyn EventBus>,
) -> Self {
Self {
issues,
profiles,
contexts,
factory,
structured,
policies,
events,
}
}
/// Executes the open flow.
///
/// Reopening an already-live assistant for the same ticket replaces the old
/// session after the fresh one has started. This guarantees the assistant sees
/// the latest ticket content/profile and keeps the invariant "one assistant per
/// ticket" without leaving a gap if the new launch fails.
pub async fn execute(
&self,
input: OpenTicketAssistantInput,
) -> Result<OpenTicketAssistantOutput, AppError> {
let issue = self
.issues
.get_by_ref(&input.project.root, input.issue_ref)
.await?;
let profile = find_profile(&self.profiles, input.profile_id).await?;
if !self.factory.supports(&profile) {
return Err(AppError::Invalid(format!(
"profile {} cannot start a structured ticket assistant",
input.profile_id
)));
}
let prepared = self
.contexts
.prepare_ticket_assistant_context(&input.project, &issue)
.await
.map_err(|e| AppError::Store(e.to_string()))?;
let sandbox = ticket_assistant_sandbox(&input.project.root, input.issue_ref);
let session = self
.factory
.start(
&profile,
&prepared,
&input.project.root,
&SessionPlan::None,
Some(&sandbox),
)
.await
.map_err(AppError::from)?;
let session_id = session.id();
let requester = session_id.to_string();
let policy = AgentToolPolicy::new(
vec![
"idea_ticket_read".to_owned(),
"idea_ticket_update".to_owned(),
"idea_ticket_update_carnet".to_owned(),
],
Some(input.issue_ref),
true,
);
if let Some(old_requester) = self.structured.ticket_assistant_requester(input.issue_ref) {
self.policies.clear_policy(&old_requester);
}
let replaced = self.structured.insert_ticket_assistant(
input.issue_ref,
requester.clone(),
Arc::clone(&session),
);
self.policies.set_policy(requester.clone(), policy);
if let Some(old) = replaced {
let _ = old.shutdown().await;
}
self.events.publish(DomainEvent::TicketAssistantOpened {
issue_ref: input.issue_ref,
profile_id: input.profile_id,
});
Ok(OpenTicketAssistantOutput {
session_id,
requester,
issue_ref: input.issue_ref,
})
}
}
/// Closes an ephemeral ticket assistant chat session.
pub struct CloseTicketAssistant {
structured: Arc<StructuredSessions>,
policies: Arc<dyn AgentToolPolicyStore>,
events: Arc<dyn EventBus>,
}
/// Input for [`CloseTicketAssistant`].
pub struct CloseTicketAssistantInput {
/// Ticket reference whose assistant should be closed.
pub issue_ref: IssueRef,
}
impl CloseTicketAssistant {
/// Builds the use case.
#[must_use]
pub fn new(
structured: Arc<StructuredSessions>,
policies: Arc<dyn AgentToolPolicyStore>,
events: Arc<dyn EventBus>,
) -> Self {
Self {
structured,
policies,
events,
}
}
/// Executes the close flow.
pub async fn execute(&self, input: CloseTicketAssistantInput) -> Result<(), AppError> {
let (session, requester) = self
.structured
.remove_ticket_assistant(input.issue_ref)
.ok_or_else(|| AppError::NotFound(format!("ticket assistant {}", input.issue_ref)))?;
self.policies.clear_policy(&requester);
session.shutdown().await.map_err(AppError::from)?;
self.events.publish(DomainEvent::TicketAssistantClosed {
issue_ref: input.issue_ref,
});
Ok(())
}
}
async fn find_profile(
profiles: &Arc<dyn ProfileStore>,
profile_id: ProfileId,
) -> Result<AgentProfile, AppError> {
profiles
.list()
.await?
.into_iter()
.find(|profile| profile.id == profile_id)
.ok_or_else(|| AppError::NotFound(format!("profile {profile_id}")))
}
fn ticket_assistant_sandbox(project_root: &ProjectPath, issue_ref: IssueRef) -> SandboxPlan {
let run_dir = format!(
"{}/.ideai/run/ticket-assistant-{}",
project_root.as_str().trim_end_matches(['/', '\\']),
issue_ref.number().get()
);
SandboxPlan::project_read_only(project_root.as_str().to_owned(), run_dir)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn sandbox_uses_project_read_only_preset() {
let root = ProjectPath::new("/tmp/project").unwrap();
let issue_ref = IssueRef::from(domain::IssueNumber::new(7).unwrap());
let plan = ticket_assistant_sandbox(&root, issue_ref);
assert_eq!(plan.allowed[0].abs_root, "/tmp/project");
assert_eq!(plan.default_posture, domain::permission::Posture::Deny);
}
}