feat(maestro): name-source metadata and prompt route types

Adds NameSource (User/Generated/Haiku), the metadata keys behind it, the
POST /api/sessions/:id/prompt body, and display helpers both sidebars will
read to decide whether a name is provisional.

Refs #131
This commit is contained in:
Miguel Palhas
2026-09-02 17:46:58 +01:00
parent 63191c7be1
commit 13903aa601
3 changed files with 179 additions and 1 deletions
+68 -1
View File
@@ -5,7 +5,7 @@
use std::path::{Path, PathBuf};
use crate::Session;
use crate::{NameSource, Session};
/// The name a session was given (#125), if any. `None` for one that was never
/// renamed — clients fall back to the command.
@@ -16,6 +16,23 @@ pub fn custom_name(s: &Session) -> Option<&str> {
}
}
/// Where [`custom_name`] came from (#131). A session carrying no
/// `name_source` — one named before the field existed — reads as
/// [`NameSource::User`], so an existing name is never treated as provisional.
pub fn name_source(s: &Session) -> NameSource {
match s.metadata.get(crate::NAME_SOURCE_KEY) {
Some(serde_json::Value::String(source)) => NameSource::from_wire(source),
_ => NameSource::default(),
}
}
/// Whether the card should render its name as provisional (#131): a generated
/// handle the daemon may still replace with one derived from the first
/// prompt. Both sidebars dim exactly this (docs/SIDEBAR.md).
pub fn is_provisional_name(s: &Session) -> bool {
custom_name(s).is_some() && name_source(s) == NameSource::Generated
}
/// Collapse a daemon's home dir to `~`. `home` empty leaves the path
/// untouched. Mirrors the web's `abbreviateCwd`.
pub fn abbreviate_dir(path: &Path, home: &str) -> String {
@@ -234,6 +251,56 @@ mod tests {
}
}
/// #131: a session named before `name_source` existed reads as `User`,
/// so an existing name is never dimmed or overwritten.
#[test]
fn a_name_without_a_source_is_a_user_name() {
let mut s = session("/home/u/p");
s.metadata.insert(
crate::NAME_KEY.into(),
serde_json::Value::String("amber-falcon".into()),
);
assert_eq!(name_source(&s), NameSource::User);
assert!(!is_provisional_name(&s));
}
/// Only a generated handle is provisional; a haiku-derived name has
/// settled and renders like any other (#131).
#[test]
fn only_a_generated_name_is_provisional() {
let mut s = session("/home/u/p");
s.metadata.insert(
crate::NAME_KEY.into(),
serde_json::Value::String("amber-falcon".into()),
);
for (stored, source, provisional) in [
("Generated", NameSource::Generated, true),
("Haiku", NameSource::Haiku, false),
("User", NameSource::User, false),
// A spelling from a newer daemon degrades to the settled variant.
("Something", NameSource::User, false),
] {
s.metadata.insert(
crate::NAME_SOURCE_KEY.into(),
serde_json::Value::String(stored.into()),
);
assert_eq!(name_source(&s), source, "{stored}");
assert_eq!(is_provisional_name(&s), provisional, "{stored}");
}
}
/// A source with no name behind it is not something to dim — the card is
/// showing its command.
#[test]
fn a_source_without_a_name_is_not_provisional() {
let mut s = session("/home/u/p");
s.metadata.insert(
crate::NAME_SOURCE_KEY.into(),
serde_json::Value::String("Generated".into()),
);
assert!(!is_provisional_name(&s));
}
#[test]
fn abbreviate_dir_collapses_home() {
assert_eq!(
+96
View File
@@ -573,6 +573,75 @@ fn submit_default() -> bool {
true
}
/// Metadata key holding a session's name (#125).
pub const NAME_KEY: &str = "name";
/// Metadata key holding where that name came from (#131).
pub const NAME_SOURCE_KEY: &str = "name_source";
/// Where a session's [`NAME_KEY`] came from (#131), and so whether a client
/// renders it as settled or provisional.
///
/// Deserializes leniently, like [`ActivityState`]: an unknown spelling from a
/// newer daemon reads as [`NameSource::User`], the settled variant. A name
/// wrongly painted as settled is only a missed dimming; one wrongly painted
/// as provisional invites the daemon to overwrite a name a person chose.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Default)]
pub enum NameSource {
/// Typed by a person — in the spawn form, or through a rename. Never
/// overwritten by autonaming. The forward-compatible default, so a
/// session named by a client that predates this field is left alone.
#[default]
User,
/// The daemon's own random handle, assigned because the spawn request
/// carried no name. Provisional: rendered dimmed, and the only source
/// autonaming will replace.
Generated,
/// Derived from the session's first prompt (#131). Settled — a second
/// prompt does not rename the session again.
Haiku,
}
impl<'de> Deserialize<'de> for NameSource {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
Ok(Self::from_wire(&s))
}
}
impl NameSource {
/// Read a stored spelling, leniently: anything unrecognised is
/// [`NameSource::User`].
pub fn from_wire(s: &str) -> Self {
match s {
"Generated" => Self::Generated,
"Haiku" => Self::Haiku,
_ => Self::User,
}
}
/// The spelling stored in `metadata`.
pub fn as_str(self) -> &'static str {
match self {
Self::User => "User",
Self::Generated => "Generated",
Self::Haiku => "Haiku",
}
}
}
/// HTTP `POST /api/sessions/:id/prompt` body (#131): the first prompt an
/// agent running in the session received. Agent-agnostic — Claude Code posts
/// it from a `UserPromptSubmit` hook, and any other agent's hook writes the
/// same shape.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SessionPromptRequest {
pub prompt: String,
}
/// Longest session name the daemon stores (#125), in characters. A name is a
/// sidebar card's line 1; past this it only truncates on every client anyway.
pub const MAX_SESSION_NAME_LEN: usize = 64;
@@ -1068,6 +1137,33 @@ mod tests {
assert_eq!(capped.chars().count(), MAX_SESSION_NAME_LEN);
}
/// #131: the prompt body round-trips whatever the agent sent, quotes and
/// newlines included — the hook posts its payload verbatim rather than
/// building JSON in shell.
#[test]
fn prompt_request_round_trips_awkward_text() {
let req = SessionPromptRequest {
prompt: "fix \"the\" parser\nthen run tests".into(),
};
assert_eq!(req, round_trip(&req));
}
/// The stored spelling and the parse of it agree, and anything else is
/// the settled default (#131).
#[test]
fn name_source_spellings_round_trip_and_degrade_to_user() {
for source in [NameSource::User, NameSource::Generated, NameSource::Haiku] {
assert_eq!(NameSource::from_wire(source.as_str()), source);
assert_eq!(
serde_json::to_value(source).unwrap(),
serde_json::Value::String(source.as_str().into())
);
assert_eq!(round_trip(&source), source);
}
assert_eq!(NameSource::from_wire("Rolled"), NameSource::User);
assert_eq!(NameSource::default(), NameSource::User);
}
#[test]
fn rename_request_round_trips() {
let req = RenameSessionRequest {
+15
View File
@@ -49,6 +49,12 @@ pub fn session_activity(id: Uuid) -> String {
format!("{SESSIONS}/{id}/activity")
}
/// `POST /api/sessions/:id/prompt` (#131): an agent reports the prompt it was
/// just given, so the daemon can name the session after the first one.
pub fn session_prompt(id: Uuid) -> String {
format!("{SESSIONS}/{id}/prompt")
}
/// `POST /api/sessions/:id/input`: type text into a session's pane.
pub fn session_input(id: Uuid) -> String {
format!("{SESSIONS}/{id}/input")
@@ -65,6 +71,7 @@ pub mod patterns {
pub const SESSION: &str = "/api/sessions/:id";
pub const SESSION_ACTIVITY: &str = "/api/sessions/:id/activity";
pub const SESSION_INPUT: &str = "/api/sessions/:id/input";
pub const SESSION_PROMPT: &str = "/api/sessions/:id/prompt";
pub const ATTACH: &str = "/api/attach/:id";
}
@@ -180,6 +187,10 @@ mod tests {
session_input(id()),
"/api/sessions/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50/input"
);
assert_eq!(
session_prompt(id()),
"/api/sessions/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50/prompt"
);
assert_eq!(
attach(id()),
"/api/attach/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50"
@@ -206,6 +217,10 @@ mod tests {
patterns::SESSION_INPUT.trim_end_matches(":id/input"),
session(id()).trim_end_matches(&id().to_string())
);
assert_eq!(
patterns::SESSION_PROMPT.trim_end_matches(":id/prompt"),
session(id()).trim_end_matches(&id().to_string())
);
assert_eq!(
patterns::ATTACH.trim_end_matches(":id"),
attach(id()).trim_end_matches(&id().to_string())