use std::io::{BufRead, Read, Write};
use std::net::TcpStream;
use std::path::{Path, PathBuf};
use std::time::Duration;
use crate::cli::HookSubcommand;
const PORT_FILE: &str = ".symforge/sidecar.port";
const SESSION_FILE: &str = ".symforge/sidecar.session";
const ADOPTION_LOG_FILE: &str = ".symforge/hook-adoption.log";
const HTTP_TIMEOUT: Duration = Duration::from_millis(50);
const DAEMON_FALLBACK_DEADLINE: Duration = Duration::from_millis(500);
#[derive(serde::Deserialize, Default)]
pub(crate) struct HookInput {
pub(crate) tool_name: Option<String>,
pub(crate) tool_input: Option<HookToolInput>,
pub(crate) cwd: Option<String>,
pub(crate) prompt: Option<String>,
}
#[derive(serde::Deserialize, Default)]
pub(crate) struct HookToolInput {
pub(crate) file_path: Option<String>,
pub(crate) pattern: Option<String>,
pub(crate) path: Option<String>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum HookWorkflow {
SourceRead,
SourceSearch,
RepoStart,
PromptContext,
PostEditImpact,
CodeEdit,
PassThrough,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum HookOutcome {
Routed,
NoSidecar,
SidecarError,
DaemonFallback,
}
impl HookOutcome {
pub(crate) fn label(self) -> &'static str {
match self {
HookOutcome::Routed => "routed",
HookOutcome::NoSidecar => "no-sidecar",
HookOutcome::SidecarError => "sidecar-error",
HookOutcome::DaemonFallback => "daemon-fallback",
}
}
fn parse(raw: &str) -> Option<Self> {
match raw {
"routed" => Some(HookOutcome::Routed),
"no-sidecar" => Some(HookOutcome::NoSidecar),
"sidecar-error" => Some(HookOutcome::SidecarError),
"daemon-fallback" => Some(HookOutcome::DaemonFallback),
_ => None,
}
}
}
#[derive(Default, Clone, Debug, PartialEq, Eq)]
pub(crate) struct WorkflowAdoptionCounts {
pub routed: usize,
pub no_sidecar: usize,
pub sidecar_error: usize,
pub daemon_fallback: usize,
}
impl WorkflowAdoptionCounts {
fn record(&mut self, outcome: HookOutcome) {
match outcome {
HookOutcome::Routed => self.routed += 1,
HookOutcome::NoSidecar => self.no_sidecar += 1,
HookOutcome::SidecarError => self.sidecar_error += 1,
HookOutcome::DaemonFallback => self.daemon_fallback += 1,
}
}
pub(crate) fn total(&self) -> usize {
self.routed + self.no_sidecar + self.sidecar_error + self.daemon_fallback
}
pub(crate) fn fail_open(&self) -> usize {
self.no_sidecar + self.sidecar_error
}
}
#[derive(Default, Clone, Debug, PartialEq, Eq)]
pub(crate) struct HookAdoptionSnapshot {
pub source_read: WorkflowAdoptionCounts,
pub source_search: WorkflowAdoptionCounts,
pub repo_start: WorkflowAdoptionCounts,
pub prompt_context: WorkflowAdoptionCounts,
pub post_edit_impact: WorkflowAdoptionCounts,
pub first_repo_start: Option<HookOutcome>,
}
impl HookAdoptionSnapshot {
fn counts_mut(&mut self, workflow: HookWorkflow) -> Option<&mut WorkflowAdoptionCounts> {
match workflow {
HookWorkflow::SourceRead => Some(&mut self.source_read),
HookWorkflow::SourceSearch => Some(&mut self.source_search),
HookWorkflow::RepoStart => Some(&mut self.repo_start),
HookWorkflow::PromptContext => Some(&mut self.prompt_context),
HookWorkflow::PostEditImpact => Some(&mut self.post_edit_impact),
HookWorkflow::CodeEdit | HookWorkflow::PassThrough => None,
}
}
pub(crate) fn total_attempts(&self) -> usize {
self.source_read.total()
+ self.source_search.total()
+ self.repo_start.total()
+ self.prompt_context.total()
+ self.post_edit_impact.total()
}
pub(crate) fn total_routed(&self) -> usize {
self.source_read.routed
+ self.source_read.daemon_fallback
+ self.source_search.routed
+ self.source_search.daemon_fallback
+ self.repo_start.routed
+ self.repo_start.daemon_fallback
+ self.prompt_context.routed
+ self.prompt_context.daemon_fallback
+ self.post_edit_impact.routed
+ self.post_edit_impact.daemon_fallback
}
pub(crate) fn total_fail_open(&self) -> usize {
self.source_read.fail_open()
+ self.source_search.fail_open()
+ self.repo_start.fail_open()
+ self.prompt_context.fail_open()
+ self.post_edit_impact.fail_open()
}
pub(crate) fn is_empty(&self) -> bool {
self.total_attempts() == 0
}
}
pub fn run_hook(subcommand: Option<&HookSubcommand>) -> anyhow::Result<()> {
let verbose = is_hook_verbose();
let input = parse_stdin_input();
if matches!(subcommand, Some(HookSubcommand::PreTool)) {
let suggestion = pre_tool_suggestion(&input);
if !suggestion.is_empty() {
println!("{}", success_json("PreToolUse", &json_escape(&suggestion)));
}
return Ok(());
}
let resolved = if let Some(sub) = subcommand {
Some(sub.clone())
} else {
resolve_subcommand_from_input(&input)
};
let event_name = resolved
.as_ref()
.map(event_name_for)
.unwrap_or("PostToolUse");
let workflow = workflow_for_subcommand(resolved.as_ref(), &input);
let session_id = read_session_file().ok();
if workflow == HookWorkflow::PassThrough {
if verbose {
eprintln!("[symforge-hook] workflow=PassThrough — emitting fail-open");
}
println!("{}", fail_open_json(event_name));
return Ok(());
}
let (port, effective_session_id, used_daemon_fallback) = match read_port_file() {
Ok(p) => {
if verbose {
eprintln!("[symforge-hook] read port file: port={p}");
}
(p, session_id.clone(), false)
}
Err(e) => {
let repo_root = std::env::current_dir().unwrap_or_default();
let port_file_path = repo_root.join(PORT_FILE);
if verbose {
eprintln!(
"[symforge-hook] port file not readable: {e} (searched {})",
port_file_path.display()
);
}
if verbose {
eprintln!("[symforge-hook] attempting daemon fallback...");
}
match try_daemon_fallback(&repo_root) {
Some(fallback) => {
if verbose {
eprintln!(
"[symforge-hook] daemon fallback succeeded: port={}, session={}",
fallback.daemon_port, fallback.session_id
);
}
(fallback.daemon_port, Some(fallback.session_id), true)
}
None => {
if verbose {
eprintln!("[symforge-hook] daemon fallback failed — no active session");
}
emit_no_sidecar_diagnostic(&repo_root, &port_file_path);
maybe_emit_sidecar_hint(&repo_root);
if verbose {
eprintln!("[symforge-hook] outcome=NoSidecar reason=sidecar_port_missing");
}
record_hook_outcome_with_detail(
workflow,
HookOutcome::NoSidecar,
session_id.as_deref(),
Some(NoSidecarDetail {
reason: "sidecar_port_missing",
searched_path: &port_file_path.to_string_lossy(),
suggestion: "start_mcp_session",
project_root: &repo_root.to_string_lossy(),
}),
);
println!("{}", fail_open_json(event_name));
return Ok(());
}
}
}
};
let resolved_ref = resolved.as_ref();
let (path, query) = endpoint_for(resolved_ref, &input);
let request_path = proxy_path(path, effective_session_id.as_deref());
if verbose {
eprintln!("[symforge-hook] HTTP GET 127.0.0.1:{port}{request_path}?{query}");
}
let body = match sync_http_get(port, &request_path, query) {
Ok(b) => b,
Err(_) => {
let repo_root = std::env::current_dir().unwrap_or_default();
let port_file_path = repo_root.join(PORT_FILE);
if verbose {
eprintln!(
"[symforge-hook] HTTP request failed — classifying as sidecar_port_stale"
);
}
maybe_emit_sidecar_hint(&repo_root);
if verbose {
eprintln!("[symforge-hook] outcome=NoSidecar reason=sidecar_port_stale");
}
record_hook_outcome_with_detail(
workflow,
HookOutcome::NoSidecar,
effective_session_id.as_deref(),
Some(NoSidecarDetail {
reason: "sidecar_port_stale",
searched_path: &port_file_path.to_string_lossy(),
suggestion: "restart_sidecar",
project_root: &repo_root.to_string_lossy(),
}),
);
println!("{}", fail_open_json(event_name));
return Ok(());
}
};
let outcome = if used_daemon_fallback {
HookOutcome::DaemonFallback
} else {
HookOutcome::Routed
};
if verbose {
eprintln!("[symforge-hook] outcome={}", outcome.label());
}
record_hook_outcome(workflow, outcome, effective_session_id.as_deref());
println!("{}", success_json(event_name, &body));
Ok(())
}
pub(crate) fn parse_stdin_input() -> HookInput {
let stdin = std::io::stdin();
let mut raw = String::new();
for line in stdin.lock().lines() {
match line {
Ok(l) => {
raw.push_str(&l);
raw.push('\n');
}
Err(_) => break,
}
}
serde_json::from_str(&raw).unwrap_or_default()
}
pub(crate) fn relative_path(absolute: &str, cwd: &str) -> String {
let abs = std::path::Path::new(absolute);
let base = std::path::Path::new(cwd);
match abs.strip_prefix(base) {
Ok(rel) => rel.to_string_lossy().replace('\\', "/"),
Err(_) => absolute.to_string(),
}
}
fn resolve_subcommand_from_input(input: &HookInput) -> Option<HookSubcommand> {
if input.prompt.as_deref().is_some() {
return Some(HookSubcommand::PromptSubmit);
}
match input.tool_name.as_deref() {
Some("Read") => Some(HookSubcommand::Read),
Some("Edit") => Some(HookSubcommand::Edit),
Some("Write") => Some(HookSubcommand::Write),
Some("Grep") => Some(HookSubcommand::Grep),
_ => None,
}
}
pub fn event_name_for(subcommand: &HookSubcommand) -> &'static str {
match subcommand {
HookSubcommand::SessionStart => "SessionStart",
HookSubcommand::PromptSubmit => "UserPromptSubmit",
HookSubcommand::PreTool => "PreToolUse",
_ => "PostToolUse",
}
}
fn pre_tool_suggestion(input: &HookInput) -> String {
let tool = input.tool_name.as_deref().unwrap_or("");
let cwd = input.cwd.as_deref().unwrap_or("");
let file = extract_file_path(input, cwd);
let pattern = input
.tool_input
.as_ref()
.and_then(|ti| ti.pattern.as_deref().or(ti.path.as_deref()))
.unwrap_or("");
match pre_tool_workflow(input) {
HookWorkflow::SourceSearch if !pattern.is_empty() => format!(
"SymForge can answer this more directly. Start with search_text(query=\"{pattern}\") for symbol-aware source matches, or search_symbols(query=\"{pattern}\") if this is likely a symbol name."
),
HookWorkflow::SourceSearch => "SymForge can answer this more directly. Prefer search_text for source-code search with enclosing symbol context, or search_symbols when you are searching by name/kind.".to_string(),
HookWorkflow::SourceRead if !file.is_empty() => format!(
"SymForge can answer this more efficiently. Start with get_file_context(path=\"{file}\") for structure and key references, or get_symbol/get_symbol_context if you only need a specific symbol."
),
HookWorkflow::SourceRead => "SymForge can answer this more efficiently. Prefer get_file_context for source-file structure and get_symbol/get_symbol_context for targeted symbol reads.".to_string(),
HookWorkflow::CodeEdit => "SymForge MCP is connected. Prefer replace_symbol_body, edit_within_symbol, or batch_edit over Edit for source code modifications — they resolve by symbol name, auto-indent, and re-index atomically.".to_string(),
HookWorkflow::PassThrough if tool == "Glob" && !pattern.is_empty() => format!(
"SymForge can narrow this faster. Prefer search_files(query=\"{pattern}\") for ranked path discovery, or get_repo_map if you need a project overview first."
),
HookWorkflow::PassThrough if tool == "Glob" => "SymForge can narrow this faster. Prefer search_files for ranked path discovery, or get_repo_map for repository overview.".to_string(),
_ => String::new(),
}
}
fn pre_tool_workflow(input: &HookInput) -> HookWorkflow {
let tool = input.tool_name.as_deref().unwrap_or("");
let file_path = input
.tool_input
.as_ref()
.and_then(|ti| ti.file_path.as_deref())
.unwrap_or("");
match tool {
"Read" if !should_fail_open_read(file_path) => HookWorkflow::SourceRead,
"Grep" => HookWorkflow::SourceSearch,
"Edit" => HookWorkflow::CodeEdit,
_ => HookWorkflow::PassThrough,
}
}
fn workflow_for_subcommand(subcommand: Option<&HookSubcommand>, input: &HookInput) -> HookWorkflow {
match subcommand {
Some(HookSubcommand::Read) if !should_fail_open_read(&extract_file_path(input, "")) => {
HookWorkflow::SourceRead
}
Some(HookSubcommand::Read) => HookWorkflow::PassThrough,
Some(HookSubcommand::Grep) => HookWorkflow::SourceSearch,
Some(HookSubcommand::SessionStart) => HookWorkflow::RepoStart,
Some(HookSubcommand::PromptSubmit) => HookWorkflow::PromptContext,
Some(HookSubcommand::Edit | HookSubcommand::Write) => HookWorkflow::PostEditImpact,
Some(HookSubcommand::PreTool) => pre_tool_workflow(input),
None => HookWorkflow::PassThrough,
}
}
fn should_fail_open_read(path: &str) -> bool {
if is_non_source_path(path) {
return true;
}
let p = path.replace('\\', "/").to_lowercase();
let literal_read_exts = [
".md", ".mdx", ".txt", ".json", ".toml", ".yaml", ".yml", ".env",
];
literal_read_exts.iter().any(|ext| p.ends_with(ext))
}
fn is_non_source_path(path: &str) -> bool {
let p = path.replace('\\', "/").to_lowercase();
let non_source_exts = [
".txt",
".xml",
".csv",
".lock",
".gitignore",
".dockerignore",
".editorconfig",
".prettierrc",
".eslintrc",
".ini",
".cfg",
".conf",
".html",
".css",
".svg",
".png",
".jpg",
".jpeg",
".gif",
".ico",
];
if non_source_exts.iter().any(|ext| p.ends_with(ext)) {
return true;
}
let non_source_dirs = [
"/docs/",
"/doc/",
"/.github/",
"/.planning/",
"/.claude/",
"/.gemini/",
"/.codex/",
"/node_modules/",
"/.git/",
];
if non_source_dirs.iter().any(|dir| p.contains(dir)) {
return true;
}
false
}
pub(crate) fn endpoint_for(
subcommand: Option<&HookSubcommand>,
input: &HookInput,
) -> (&'static str, String) {
let cwd = input.cwd.as_deref().unwrap_or("");
match subcommand {
Some(HookSubcommand::Read) => {
let file = extract_file_path(input, cwd);
let query = if file.is_empty() {
String::new()
} else {
format!("path={}", url_encode(&file))
};
("/outline", query)
}
Some(HookSubcommand::Edit) => {
let file = extract_file_path(input, cwd);
let query = if file.is_empty() {
String::new()
} else {
format!("path={}", url_encode(&file))
};
("/impact", query)
}
Some(HookSubcommand::Write) => {
let file = extract_file_path(input, cwd);
let query = if file.is_empty() {
"new_file=true".to_string()
} else {
format!("path={}&new_file=true", url_encode(&file))
};
("/impact", query)
}
Some(HookSubcommand::Grep) => {
let q = input
.tool_input
.as_ref()
.and_then(|ti| ti.pattern.as_deref().or(ti.path.as_deref()))
.unwrap_or("");
let query = if q.is_empty() {
String::new()
} else {
format!("name={}", url_encode(q))
};
("/symbol-context", query)
}
Some(HookSubcommand::SessionStart) => ("/repo-map", String::new()),
Some(HookSubcommand::PromptSubmit) => {
let prompt = input.prompt.as_deref().unwrap_or("");
let query = if prompt.is_empty() {
String::new()
} else {
format!("text={}", url_encode(prompt))
};
("/prompt-context", query)
}
Some(HookSubcommand::PreTool) => ("/health", String::new()),
None => ("/health", String::new()),
}
}
pub fn fail_open_json(event_name: &str) -> String {
format!(r#"{{"hookSpecificOutput":{{"hookEventName":"{event_name}","additionalContext":""}}}}"#)
}
pub fn success_json(event_name: &str, context: &str) -> String {
let escaped = json_escape(context);
format!(
r#"{{"hookSpecificOutput":{{"hookEventName":"{event_name}","additionalContext":"{escaped}"}}}}"#
)
}
fn extract_file_path(input: &HookInput, cwd: &str) -> String {
let abs = input
.tool_input
.as_ref()
.and_then(|ti| ti.file_path.as_deref())
.unwrap_or("");
if abs.is_empty() || cwd.is_empty() {
abs.to_string()
} else {
relative_path(abs, cwd)
}
}
fn read_port_file() -> std::io::Result<u16> {
let contents = std::fs::read_to_string(PORT_FILE)?;
contents
.trim()
.parse::<u16>()
.map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))
}
fn read_session_file() -> std::io::Result<String> {
let contents = std::fs::read_to_string(SESSION_FILE)?;
Ok(contents.trim().to_string())
}
fn proxy_path(base_path: &str, session_id: Option<&str>) -> String {
match session_id {
Some(session_id) if !session_id.trim().is_empty() => {
format!("/v1/sessions/{}/sidecar{}", session_id.trim(), base_path)
}
_ => base_path.to_string(),
}
}
fn tracked_workflow_name(workflow: HookWorkflow) -> Option<&'static str> {
match workflow {
HookWorkflow::SourceRead => Some("source-read"),
HookWorkflow::SourceSearch => Some("source-search"),
HookWorkflow::RepoStart => Some("repo-start"),
HookWorkflow::PromptContext => Some("prompt-context"),
HookWorkflow::PostEditImpact => Some("post-edit-impact"),
HookWorkflow::CodeEdit | HookWorkflow::PassThrough => None,
}
}
fn parse_tracked_workflow(raw: &str) -> Option<HookWorkflow> {
match raw {
"source-read" => Some(HookWorkflow::SourceRead),
"source-search" => Some(HookWorkflow::SourceSearch),
"repo-start" => Some(HookWorkflow::RepoStart),
"prompt-context" => Some(HookWorkflow::PromptContext),
"post-edit-impact" => Some(HookWorkflow::PostEditImpact),
_ => None,
}
}
fn record_hook_outcome(workflow: HookWorkflow, outcome: HookOutcome, session_id: Option<&str>) {
let Some(workflow_name) = tracked_workflow_name(workflow) else {
return;
};
let _ = append_hook_adoption_event(
Path::new(ADOPTION_LOG_FILE),
session_id,
workflow_name,
outcome.label(),
);
}
struct DaemonFallbackResult {
daemon_port: u16,
session_id: String,
}
fn try_daemon_fallback(repo_root: &Path) -> Option<DaemonFallbackResult> {
let deadline = std::time::Instant::now() + DAEMON_FALLBACK_DEADLINE;
let daemon_port = crate::daemon::read_daemon_port_file().ok()?;
let remaining = deadline.checked_duration_since(std::time::Instant::now())?;
let projects_json =
sync_http_get_with_timeout(daemon_port, "/v1/projects", String::new(), remaining).ok()?;
let canon_root = std::fs::canonicalize(repo_root).unwrap_or_else(|_| repo_root.to_path_buf());
let canon_root_str = normalize_path_for_match(&canon_root);
let projects: Vec<DaemonProjectEntry> = serde_json::from_str(&projects_json).ok()?;
let matching = projects
.iter()
.find(|p| normalize_path_for_match(Path::new(&p.canonical_root)) == canon_root_str)?;
if matching.session_count == 0 {
return None;
}
let remaining = deadline.checked_duration_since(std::time::Instant::now())?;
let sessions_path = format!("/v1/projects/{}/sessions", url_encode(&matching.project_id));
let sessions_json =
sync_http_get_with_timeout(daemon_port, &sessions_path, String::new(), remaining).ok()?;
let sessions: Vec<DaemonSessionEntry> = serde_json::from_str(&sessions_json).ok()?;
let session = sessions.iter().max_by_key(|s| s.last_seen_at_unix_secs)?;
Some(DaemonFallbackResult {
daemon_port,
session_id: session.session_id.clone(),
})
}
#[derive(serde::Deserialize)]
struct DaemonProjectEntry {
project_id: String,
canonical_root: String,
session_count: usize,
}
#[derive(serde::Deserialize)]
struct DaemonSessionEntry {
session_id: String,
last_seen_at_unix_secs: u64,
}
fn normalize_path_for_match(path: &Path) -> String {
let s = path.to_string_lossy().replace('\\', "/");
let trimmed = s.trim_end_matches('/');
if cfg!(windows) {
trimmed.to_lowercase()
} else {
trimmed.to_string()
}
}
fn sync_http_get_with_timeout(
port: u16,
path: &str,
query: String,
timeout: Duration,
) -> anyhow::Result<String> {
let addr = format!("127.0.0.1:{port}");
let sock_addr: std::net::SocketAddr = addr.parse()?;
let mut stream = TcpStream::connect_timeout(&sock_addr, timeout)?;
stream.set_read_timeout(Some(timeout))?;
stream.set_write_timeout(Some(timeout))?;
let request_path = if query.is_empty() {
path.to_string()
} else {
format!("{path}?{query}")
};
let request = format!(
"GET {request_path} HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\nConnection: close\r\n\r\n"
);
stream.write_all(request.as_bytes())?;
let mut response = String::new();
stream.read_to_string(&mut response)?;
let (headers, body) = response
.split_once("\r\n\r\n")
.ok_or_else(|| anyhow::anyhow!("malformed HTTP response: no header/body separator"))?;
let status_line = headers
.lines()
.next()
.ok_or_else(|| anyhow::anyhow!("malformed HTTP response: empty headers"))?;
let status_code: u16 = status_line
.split_whitespace()
.nth(1)
.ok_or_else(|| anyhow::anyhow!("malformed HTTP status line: {status_line}"))?
.parse()
.map_err(|_| anyhow::anyhow!("non-numeric HTTP status code in: {status_line}"))?;
if !(200..=299).contains(&status_code) {
anyhow::bail!("HTTP {status_code} from {path}");
}
let is_chunked = headers.lines().any(|line| {
let lower = line.to_lowercase();
lower.starts_with("transfer-encoding:") && lower.contains("chunked")
});
if is_chunked {
Ok(decode_chunked_body(body))
} else {
Ok(body.to_string())
}
}
fn decode_chunked_body(raw: &str) -> String {
let mut result = String::new();
let mut remainder = raw;
while let Some(size_end) = remainder.find("\r\n") {
let size_str = remainder[..size_end].trim();
let chunk_size = match usize::from_str_radix(size_str, 16) {
Ok(0) => break, Ok(n) => n,
Err(_) => break, };
let data_start = size_end + 2; if data_start + chunk_size > remainder.len() {
result.push_str(&remainder[data_start..]);
break;
}
result.push_str(&remainder[data_start..data_start + chunk_size]);
let next = data_start + chunk_size + 2;
if next > remainder.len() {
break;
}
remainder = &remainder[next..];
}
result
}
struct NoSidecarDetail<'a> {
reason: &'a str,
searched_path: &'a str,
suggestion: &'a str,
project_root: &'a str,
}
fn is_hook_verbose() -> bool {
std::env::var("SYMFORGE_HOOK_VERBOSE").is_ok_and(|v| v == "1")
}
const HOOK_HINT_MARKER: &str = ".symforge/hook-hint-shown";
const HOOK_HINT_FRESHNESS: Duration = Duration::from_secs(30 * 60);
fn maybe_emit_sidecar_hint(repo_root: &Path) {
let marker_path = repo_root.join(HOOK_HINT_MARKER);
if let Ok(metadata) = std::fs::metadata(&marker_path)
&& let Ok(modified) = metadata.modified()
&& let Ok(elapsed) = modified.elapsed()
&& elapsed < HOOK_HINT_FRESHNESS
{
return;
}
eprintln!("[symforge-hook] SymForge sidecar is not running. To enable rich context:");
eprintln!(
"[symforge-hook] \u{2022} Configure SymForge as an MCP server in your editor settings"
);
eprintln!("[symforge-hook] \u{2022} Or run: symforge --stdio");
eprintln!("[symforge-hook] (This hint appears once per session)");
if let Some(parent) = marker_path.parent() {
let _ = std::fs::create_dir_all(parent);
}
let _ = std::fs::write(&marker_path, "");
}
fn emit_no_sidecar_diagnostic(repo_root: &Path, port_file_path: &Path) {
if !is_hook_verbose() {
return;
}
let daemon_status = if crate::daemon::read_daemon_port_file().is_ok() {
"SymForge daemon is running but has no active session for this project."
} else {
"SymForge daemon is not running."
};
eprintln!(
"[symforge-hook] sidecar not running. No {} found in {}.",
PORT_FILE,
repo_root.display()
);
eprintln!("[symforge-hook] Searched: {}", port_file_path.display());
eprintln!("[symforge-hook] {daemon_status}");
eprintln!(
"[symforge-hook] To start: run 'symforge' as an MCP server, or start a Claude/Codex session with SymForge configured."
);
eprintln!("[symforge-hook] Hook falling back to pass-through mode.");
}
fn record_hook_outcome_with_detail(
workflow: HookWorkflow,
outcome: HookOutcome,
session_id: Option<&str>,
detail: Option<NoSidecarDetail<'_>>,
) {
let Some(workflow_name) = tracked_workflow_name(workflow) else {
return;
};
let _ = append_hook_adoption_event_with_detail(
Path::new(ADOPTION_LOG_FILE),
session_id,
workflow_name,
outcome.label(),
detail,
);
}
fn append_hook_adoption_event_with_detail(
log_path: &Path,
session_id: Option<&str>,
workflow_name: &str,
outcome_label: &str,
detail: Option<NoSidecarDetail<'_>>,
) -> std::io::Result<()> {
if let Some(parent) = log_path.parent() {
std::fs::create_dir_all(parent)?;
}
let mut file = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open(log_path)?;
let session = session_id
.map(str::trim)
.filter(|value| !value.is_empty())
.unwrap_or("-");
match detail {
Some(d) => writeln!(
file,
"{session}\t{workflow_name}\t{outcome_label}\treason={}\tsearched_path={}\tsuggestion={}\tproject_root={}",
d.reason, d.searched_path, d.suggestion, d.project_root
),
None => writeln!(file, "{session}\t{workflow_name}\t{outcome_label}"),
}
}
fn append_hook_adoption_event(
log_path: &Path,
session_id: Option<&str>,
workflow_name: &str,
outcome_label: &str,
) -> std::io::Result<()> {
if let Some(parent) = log_path.parent() {
std::fs::create_dir_all(parent)?;
}
let mut file = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open(log_path)?;
let session = session_id
.map(str::trim)
.filter(|value| !value.is_empty())
.unwrap_or("-");
writeln!(file, "{session}\t{workflow_name}\t{outcome_label}")
}
fn adoption_log_path(repo_root: Option<&Path>) -> PathBuf {
repo_root
.unwrap_or_else(|| Path::new("."))
.join(ADOPTION_LOG_FILE)
}
fn session_file_path(repo_root: Option<&Path>) -> PathBuf {
repo_root
.unwrap_or_else(|| Path::new("."))
.join(SESSION_FILE)
}
fn read_session_id_for_repo(repo_root: Option<&Path>) -> Option<String> {
std::fs::read_to_string(session_file_path(repo_root))
.ok()
.map(|text| text.trim().to_string())
.filter(|value| !value.is_empty())
}
fn load_hook_adoption_snapshot_from_path(
log_path: &Path,
session_filter: Option<&str>,
) -> std::io::Result<HookAdoptionSnapshot> {
let Ok(contents) = std::fs::read_to_string(log_path) else {
return Ok(HookAdoptionSnapshot::default());
};
let mut snapshot = HookAdoptionSnapshot::default();
for line in contents.lines() {
let mut parts = line.split('\t');
let Some(session_id) = parts.next() else {
continue;
};
let Some(workflow_raw) = parts.next() else {
continue;
};
let Some(outcome_raw) = parts.next() else {
continue;
};
if let Some(filter) = session_filter
&& session_id != filter
{
continue;
}
let Some(workflow) = parse_tracked_workflow(workflow_raw) else {
continue;
};
let Some(outcome) = HookOutcome::parse(outcome_raw) else {
continue;
};
if workflow == HookWorkflow::RepoStart && snapshot.first_repo_start.is_none() {
snapshot.first_repo_start = Some(outcome);
}
if let Some(counts) = snapshot.counts_mut(workflow) {
counts.record(outcome);
}
}
Ok(snapshot)
}
pub(crate) fn load_hook_adoption_snapshot(repo_root: Option<&Path>) -> HookAdoptionSnapshot {
let session = read_session_id_for_repo(repo_root);
load_hook_adoption_snapshot_from_path(&adoption_log_path(repo_root), session.as_deref())
.unwrap_or_default()
}
fn sync_http_get(port: u16, path: &str, query: String) -> anyhow::Result<String> {
sync_http_get_with_timeout(port, path, query, HTTP_TIMEOUT)
}
fn url_encode(s: &str) -> String {
let mut out = String::with_capacity(s.len());
for b in s.bytes() {
match b {
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' | b'/' | b':' => {
out.push(b as char)
}
b => out.push_str(&format!("%{b:02X}")),
}
}
out
}
fn json_escape(s: &str) -> String {
let mut out = String::with_capacity(s.len());
for c in s.chars() {
match c {
'"' => out.push_str("\\\""),
'\\' => out.push_str("\\\\"),
'\n' => out.push_str("\\n"),
'\r' => out.push_str("\\r"),
'\t' => out.push_str("\\t"),
c => out.push(c),
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
use once_cell::sync::Lazy;
use serde_json::Value;
use std::sync::Mutex;
use tempfile::TempDir;
static HOOK_VERBOSE_ENV_LOCK: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
#[test]
fn test_fail_open_json_is_valid() {
let json = fail_open_json("PostToolUse");
let v: Value = serde_json::from_str(&json).expect("fail_open_json must produce valid JSON");
let output = &v["hookSpecificOutput"];
assert_eq!(output["hookEventName"], "PostToolUse");
assert_eq!(output["additionalContext"], "");
}
#[test]
fn test_fail_open_json_session_start_event_name() {
let json = fail_open_json("SessionStart");
let v: Value = serde_json::from_str(&json).expect("must be valid JSON");
assert_eq!(v["hookSpecificOutput"]["hookEventName"], "SessionStart");
}
#[test]
fn test_success_json_is_valid() {
let json = success_json("PostToolUse", "hello world");
let v: Value = serde_json::from_str(&json).expect("success_json must produce valid JSON");
let output = &v["hookSpecificOutput"];
assert_eq!(output["hookEventName"], "PostToolUse");
assert_eq!(output["additionalContext"], "hello world");
}
#[test]
fn test_success_json_escapes_special_chars() {
let context = r#"{"key":"value"}"#;
let json = success_json("PostToolUse", context);
let v: Value = serde_json::from_str(&json)
.expect("success_json with embedded quotes must be valid JSON");
let ctx = v["hookSpecificOutput"]["additionalContext"]
.as_str()
.expect("additionalContext must be a string");
assert_eq!(ctx, context);
}
#[test]
fn test_parse_stdin_returns_default_on_empty() {
let result: HookInput = serde_json::from_str("").unwrap_or_default();
assert!(result.tool_name.is_none());
assert!(result.tool_input.is_none());
assert!(result.cwd.is_none());
}
#[test]
fn test_parse_stdin_deserializes_read_payload() {
let json =
r#"{"tool_name":"Read","tool_input":{"file_path":"/abs/src/foo.rs"},"cwd":"/abs"}"#;
let result: HookInput = serde_json::from_str(json).unwrap_or_default();
assert_eq!(result.tool_name.as_deref(), Some("Read"));
assert_eq!(
result
.tool_input
.as_ref()
.and_then(|ti| ti.file_path.as_deref()),
Some("/abs/src/foo.rs")
);
assert_eq!(result.cwd.as_deref(), Some("/abs"));
}
#[test]
fn test_parse_stdin_deserializes_grep_payload() {
let json = r#"{"tool_name":"Grep","tool_input":{"pattern":"TODO","path":"/abs/src"},"cwd":"/abs"}"#;
let result: HookInput = serde_json::from_str(json).unwrap_or_default();
assert_eq!(result.tool_name.as_deref(), Some("Grep"));
let ti = result.tool_input.as_ref().unwrap();
assert_eq!(ti.pattern.as_deref(), Some("TODO"));
assert_eq!(ti.path.as_deref(), Some("/abs/src"));
}
#[test]
fn test_parse_stdin_returns_default_on_invalid_json() {
let result: HookInput = serde_json::from_str("not valid json").unwrap_or_default();
assert!(result.tool_name.is_none());
}
#[test]
fn test_relative_path_strips_unix_cwd_prefix() {
let rel = relative_path("/home/user/project/src/foo.rs", "/home/user/project");
assert_eq!(rel, "src/foo.rs");
}
#[test]
fn test_relative_path_strips_windows_cwd_prefix() {
let rel = relative_path("C:/Users/dev/project/src/foo.rs", "C:/Users/dev/project");
assert!(
rel.contains("src/foo.rs") || rel == "C:/Users/dev/project/src/foo.rs",
"got: {rel}"
);
}
#[test]
fn test_relative_path_unchanged_when_no_prefix_match() {
let rel = relative_path("/unrelated/path.rs", "/home/user/project");
assert_eq!(rel, "/unrelated/path.rs");
}
#[test]
#[cfg(windows)]
fn test_relative_path_normalizes_backslashes() {
let rel = relative_path(
"C:\\Users\\dev\\project\\src\\foo.rs",
"C:\\Users\\dev\\project",
);
assert!(
!rel.contains('\\'),
"backslashes must be normalized to forward slashes; got: {rel}"
);
}
#[test]
fn test_endpoint_for_read_stdin_routes_to_outline() {
let input = make_input("Read", Some("/abs/src/foo.rs"), None, "/abs");
let (path, query) = endpoint_for(Some(&HookSubcommand::Read), &input);
assert_eq!(path, "/outline");
assert!(
query.contains("src/foo.rs"),
"query must include relative path; got: {query}"
);
}
#[test]
fn test_endpoint_for_edit_stdin_routes_to_impact() {
let input = make_input("Edit", Some("/abs/src/bar.rs"), None, "/abs");
let (path, query) = endpoint_for(Some(&HookSubcommand::Edit), &input);
assert_eq!(path, "/impact");
assert!(
query.contains("src/bar.rs"),
"query must include relative path; got: {query}"
);
}
#[test]
fn test_endpoint_for_write_routes_to_impact_with_new_file() {
let input = make_input("Write", Some("/abs/src/new.rs"), None, "/abs");
let (path, query) = endpoint_for(Some(&HookSubcommand::Write), &input);
assert_eq!(path, "/impact");
assert!(
query.contains("new_file=true"),
"Write must set new_file=true; got: {query}"
);
assert!(
query.contains("src/new.rs"),
"Write must include file path; got: {query}"
);
}
#[test]
fn test_endpoint_for_grep_stdin_routes_to_symbol_context() {
let json = r#"{"tool_name":"Grep","tool_input":{"pattern":"TODO","path":"/abs/src"},"cwd":"/abs"}"#;
let input: HookInput = serde_json::from_str(json).unwrap_or_default();
let (path, query) = endpoint_for(Some(&HookSubcommand::Grep), &input);
assert_eq!(path, "/symbol-context");
assert!(
query.contains("TODO"),
"Grep query must include pattern; got: {query}"
);
}
#[test]
fn test_endpoint_for_session_start_routes_to_repo_map() {
let input = HookInput::default();
let (path, query) = endpoint_for(Some(&HookSubcommand::SessionStart), &input);
assert_eq!(path, "/repo-map");
assert!(query.is_empty(), "repo-map has no query params");
}
#[test]
fn test_endpoint_for_prompt_submit_routes_to_prompt_context() {
let input = HookInput {
prompt: Some("please inspect src/foo.rs".to_string()),
..HookInput::default()
};
let (path, query) = endpoint_for(Some(&HookSubcommand::PromptSubmit), &input);
assert_eq!(path, "/prompt-context");
assert!(
query.contains("please%20inspect%20src/foo.rs"),
"prompt query must be URL-encoded; got: {query}"
);
}
#[test]
fn test_proxy_path_uses_daemon_session_namespace_when_present() {
let path = proxy_path("/repo-map", Some("session-42"));
assert_eq!(path, "/v1/sessions/session-42/sidecar/repo-map");
}
#[test]
fn test_proxy_path_returns_base_path_without_session() {
let path = proxy_path("/repo-map", None);
assert_eq!(path, "/repo-map");
}
#[test]
fn test_endpoint_for_unknown_tool_returns_fail_open() {
let input = HookInput {
tool_name: Some("UnknownTool".to_string()),
..Default::default()
};
let (path, _) = endpoint_for(None, &input);
assert_eq!(path, "/health");
}
#[test]
fn test_event_name_for_session_start() {
assert_eq!(
event_name_for(&HookSubcommand::SessionStart),
"SessionStart"
);
}
#[test]
fn test_event_name_for_prompt_submit() {
assert_eq!(
event_name_for(&HookSubcommand::PromptSubmit),
"UserPromptSubmit"
);
}
#[test]
fn test_event_name_for_post_tool_use_variants() {
for sub in [
HookSubcommand::Read,
HookSubcommand::Edit,
HookSubcommand::Write,
HookSubcommand::Grep,
] {
assert_eq!(
event_name_for(&sub),
"PostToolUse",
"Read/Edit/Write/Grep must produce PostToolUse event name"
);
}
}
#[test]
fn test_hook_subcommand_to_endpoint_read_backward_compat() {
let input = HookInput::default();
let (path, _query) = endpoint_for(Some(&HookSubcommand::Read), &input);
assert_eq!(path, "/outline");
}
#[test]
fn test_hook_subcommand_to_endpoint_edit_backward_compat() {
let input = HookInput::default();
let (path, _query) = endpoint_for(Some(&HookSubcommand::Edit), &input);
assert_eq!(path, "/impact");
}
#[test]
fn test_hook_subcommand_to_endpoint_grep_backward_compat() {
let input = HookInput::default();
let (path, _query) = endpoint_for(Some(&HookSubcommand::Grep), &input);
assert_eq!(path, "/symbol-context");
}
#[test]
fn test_hook_subcommand_to_endpoint_session_start_backward_compat() {
let input = HookInput::default();
let (path, query) = endpoint_for(Some(&HookSubcommand::SessionStart), &input);
assert_eq!(path, "/repo-map");
assert!(query.is_empty(), "repo-map has no query params");
}
#[test]
fn test_hook_subcommand_to_endpoint_prompt_submit_backward_compat() {
let input = HookInput {
prompt: Some("review MinioService".to_string()),
..HookInput::default()
};
let (path, query) = endpoint_for(Some(&HookSubcommand::PromptSubmit), &input);
assert_eq!(path, "/prompt-context");
assert!(query.contains("review%20MinioService"));
}
#[test]
fn test_resolve_subcommand_read() {
let input = HookInput {
tool_name: Some("Read".to_string()),
..Default::default()
};
assert!(matches!(
resolve_subcommand_from_input(&input),
Some(HookSubcommand::Read)
));
}
#[test]
fn test_resolve_subcommand_write() {
let input = HookInput {
tool_name: Some("Write".to_string()),
..Default::default()
};
assert!(matches!(
resolve_subcommand_from_input(&input),
Some(HookSubcommand::Write)
));
}
#[test]
fn test_resolve_subcommand_unknown_returns_none() {
let input = HookInput {
tool_name: Some("Bash".to_string()),
..Default::default()
};
assert!(resolve_subcommand_from_input(&input).is_none());
}
#[test]
fn test_pre_tool_suggestion_grep_suggests_search_text() {
let input = HookInput {
tool_name: Some("Grep".to_string()),
tool_input: Some(HookToolInput {
pattern: Some("helper".to_string()),
..Default::default()
}),
..Default::default()
};
let s = pre_tool_suggestion(&input);
assert!(s.contains("search_text"), "should suggest search_text: {s}");
assert!(
s.contains("helper"),
"should include the query in the hint: {s}"
);
}
#[test]
fn test_pre_tool_suggestion_read_source_suggests_get_file_context() {
let input = HookInput {
tool_name: Some("Read".to_string()),
tool_input: Some(HookToolInput {
file_path: Some("/repo/src/main.rs".to_string()),
..Default::default()
}),
cwd: Some("/repo".to_string()),
..Default::default()
};
let s = pre_tool_suggestion(&input);
assert!(
s.contains("get_file_context"),
"should suggest get_file_context for source: {s}"
);
assert!(
s.contains("src/main.rs"),
"should include the path hint: {s}"
);
}
#[test]
fn test_pre_tool_suggestion_read_markdown_is_empty() {
let input = HookInput {
tool_name: Some("Read".to_string()),
tool_input: Some(HookToolInput {
file_path: Some("docs/README.md".to_string()),
..Default::default()
}),
..Default::default()
};
let s = pre_tool_suggestion(&input);
assert!(
s.is_empty(),
"should stay pass-through for markdown reads: {s}"
);
}
#[test]
fn test_pre_tool_suggestion_read_csv_is_empty() {
let input = HookInput {
tool_name: Some("Read".to_string()),
tool_input: Some(HookToolInput {
file_path: Some("data/export.csv".to_string()),
..Default::default()
}),
..Default::default()
};
let s = pre_tool_suggestion(&input);
assert!(s.is_empty(), "should not suggest for .csv files: {s}");
}
#[test]
fn test_pre_tool_suggestion_glob_suggests_search_files() {
let input = HookInput {
tool_name: Some("Glob".to_string()),
..Default::default()
};
let s = pre_tool_suggestion(&input);
assert!(
s.contains("search_files"),
"should suggest search_files: {s}"
);
}
#[test]
fn test_pre_tool_suggestion_edit_suggests_replace_symbol_body() {
let input = HookInput {
tool_name: Some("Edit".to_string()),
..Default::default()
};
let s = pre_tool_suggestion(&input);
assert!(
s.contains("replace_symbol_body"),
"should suggest replace_symbol_body: {s}"
);
}
#[test]
fn test_pre_tool_workflow_classifies_source_read() {
let input = make_input("Read", Some("/repo/src/lib.rs"), None, "/repo");
assert_eq!(pre_tool_workflow(&input), HookWorkflow::SourceRead);
}
#[test]
fn test_pre_tool_workflow_leaves_non_source_read_as_passthrough() {
let input = make_input("Read", Some("/repo/docs/guide.md"), None, "/repo");
assert_eq!(pre_tool_workflow(&input), HookWorkflow::PassThrough);
}
#[test]
fn test_workflow_for_subcommand_leaves_non_source_read_as_passthrough() {
let input = make_input("Read", Some("/repo/docs/guide.md"), None, "/repo");
assert_eq!(
workflow_for_subcommand(Some(&HookSubcommand::Read), &input),
HookWorkflow::PassThrough
);
}
#[test]
fn test_workflow_for_subcommand_leaves_config_read_as_passthrough() {
let input = make_input("Read", Some("/repo/Cargo.toml"), None, "/repo");
assert_eq!(
workflow_for_subcommand(Some(&HookSubcommand::Read), &input),
HookWorkflow::PassThrough
);
}
#[test]
fn test_workflow_for_subcommand_classifies_repo_start() {
let input = HookInput::default();
assert_eq!(
workflow_for_subcommand(Some(&HookSubcommand::SessionStart), &input),
HookWorkflow::RepoStart
);
}
#[test]
fn test_workflow_for_subcommand_classifies_prompt_context() {
let input = HookInput {
prompt: Some("read src/lib.rs".to_string()),
..HookInput::default()
};
assert_eq!(
workflow_for_subcommand(Some(&HookSubcommand::PromptSubmit), &input),
HookWorkflow::PromptContext
);
}
#[test]
fn test_pre_tool_suggestion_unknown_tool_is_empty() {
let input = HookInput {
tool_name: Some("Bash".to_string()),
..Default::default()
};
let s = pre_tool_suggestion(&input);
assert!(s.is_empty(), "should not suggest for unknown tools: {s}");
}
#[test]
fn test_is_non_source_path_allows_config_files() {
assert!(!is_non_source_path("package.json"));
assert!(!is_non_source_path("Cargo.toml"));
assert!(!is_non_source_path("README.md"));
assert!(!is_non_source_path(".env"));
assert!(!is_non_source_path("config.yaml"));
assert!(!is_non_source_path("docker-compose.yml"));
}
#[test]
fn test_is_non_source_path_still_skips_non_config() {
assert!(is_non_source_path("data.csv"));
assert!(is_non_source_path("notes.txt"));
assert!(is_non_source_path("icon.png"));
assert!(is_non_source_path("Cargo.lock"));
}
#[test]
fn test_is_non_source_path_allows_source_files() {
assert!(!is_non_source_path("src/main.rs"));
assert!(!is_non_source_path("tests/test_foo.py"));
assert!(!is_non_source_path("lib/parser.js"));
}
#[test]
fn test_load_hook_adoption_snapshot_filters_to_current_session() {
let tmp = TempDir::new().unwrap();
let symforge_dir = tmp.path().join(".symforge");
std::fs::create_dir_all(&symforge_dir).unwrap();
let log_path = symforge_dir.join("hook-adoption.log");
let session_path = symforge_dir.join("sidecar.session");
append_hook_adoption_event(&log_path, Some("session-a"), "source-read", "routed").unwrap();
append_hook_adoption_event(&log_path, Some("session-a"), "repo-start", "no-sidecar")
.unwrap();
append_hook_adoption_event(&log_path, Some("session-b"), "source-search", "routed")
.unwrap();
std::fs::write(&session_path, "session-a\n").unwrap();
let snapshot = load_hook_adoption_snapshot(Some(tmp.path()));
assert_eq!(snapshot.source_read.routed, 1);
assert_eq!(snapshot.source_search.routed, 0);
assert_eq!(snapshot.repo_start.no_sidecar, 1);
assert_eq!(snapshot.first_repo_start, Some(HookOutcome::NoSidecar));
}
#[test]
fn test_load_hook_adoption_snapshot_tracks_sidecar_errors_and_totals() {
let tmp = TempDir::new().unwrap();
let log_path = tmp.path().join("hook-adoption.log");
append_hook_adoption_event(
&log_path,
Some("session-z"),
"prompt-context",
"sidecar-error",
)
.unwrap();
append_hook_adoption_event(&log_path, Some("session-z"), "post-edit-impact", "routed")
.unwrap();
append_hook_adoption_event(&log_path, Some("session-z"), "source-read", "no-sidecar")
.unwrap();
let snapshot = load_hook_adoption_snapshot_from_path(&log_path, Some("session-z")).unwrap();
assert_eq!(snapshot.prompt_context.sidecar_error, 1);
assert_eq!(snapshot.post_edit_impact.routed, 1);
assert_eq!(snapshot.source_read.no_sidecar, 1);
assert_eq!(snapshot.total_routed(), 1);
assert_eq!(snapshot.total_fail_open(), 2);
assert_eq!(snapshot.total_attempts(), 3);
}
#[test]
fn hook_verbose_returns_false_when_unset() {
let _guard = HOOK_VERBOSE_ENV_LOCK.lock().unwrap();
unsafe { std::env::remove_var("SYMFORGE_HOOK_VERBOSE") };
assert!(!is_hook_verbose());
}
#[test]
fn hook_verbose_returns_true_when_set_to_1() {
let _guard = HOOK_VERBOSE_ENV_LOCK.lock().unwrap();
unsafe { std::env::set_var("SYMFORGE_HOOK_VERBOSE", "1") };
let result = is_hook_verbose();
unsafe { std::env::remove_var("SYMFORGE_HOOK_VERBOSE") };
assert!(result);
}
#[test]
fn hook_verbose_returns_false_for_other_values() {
let _guard = HOOK_VERBOSE_ENV_LOCK.lock().unwrap();
for val in &["0", "true", "yes", "2", ""] {
unsafe { std::env::set_var("SYMFORGE_HOOK_VERBOSE", val) };
assert!(
!is_hook_verbose(),
"should be false for SYMFORGE_HOOK_VERBOSE={val}"
);
}
unsafe { std::env::remove_var("SYMFORGE_HOOK_VERBOSE") };
}
#[test]
fn adoption_log_missing_port_includes_reason_and_project_root() {
let tmp = TempDir::new().unwrap();
let log_path = tmp.path().join("hook-adoption.log");
let detail = NoSidecarDetail {
reason: "sidecar_port_missing",
searched_path: "/repo/.symforge/sidecar.port",
suggestion: "start_mcp_session",
project_root: "/repo",
};
append_hook_adoption_event_with_detail(
&log_path,
Some("sess-1"),
"source-read",
"no-sidecar",
Some(detail),
)
.unwrap();
let content = std::fs::read_to_string(&log_path).unwrap();
assert!(
content.contains("reason=sidecar_port_missing"),
"missing reason field"
);
assert!(
content.contains("project_root=/repo"),
"missing project_root field"
);
assert!(content.contains("searched_path=/repo/.symforge/sidecar.port"));
assert!(content.contains("suggestion=start_mcp_session"));
}
#[test]
fn adoption_log_stale_port_has_distinct_reason() {
let tmp = TempDir::new().unwrap();
let log_path = tmp.path().join("hook-adoption.log");
let detail = NoSidecarDetail {
reason: "sidecar_port_stale",
searched_path: "/repo/.symforge/sidecar.port",
suggestion: "restart_sidecar",
project_root: "/repo",
};
append_hook_adoption_event_with_detail(
&log_path,
Some("sess-2"),
"source-read",
"no-sidecar",
Some(detail),
)
.unwrap();
let content = std::fs::read_to_string(&log_path).unwrap();
assert!(
content.contains("reason=sidecar_port_stale"),
"should have stale reason"
);
assert!(content.contains("project_root=/repo"));
}
#[test]
fn adoption_log_without_detail_has_no_reason_or_project_root() {
let tmp = TempDir::new().unwrap();
let log_path = tmp.path().join("hook-adoption.log");
append_hook_adoption_event_with_detail(
&log_path,
Some("sess-3"),
"source-read",
"routed",
None,
)
.unwrap();
let content = std::fs::read_to_string(&log_path).unwrap();
assert!(
!content.contains("reason="),
"should have no reason without detail"
);
assert!(
!content.contains("project_root="),
"should have no project_root without detail"
);
}
#[test]
fn sidecar_hint_creates_marker_file() {
let tmp = TempDir::new().unwrap();
let marker = tmp.path().join(HOOK_HINT_MARKER);
assert!(!marker.exists());
maybe_emit_sidecar_hint(tmp.path());
assert!(marker.exists(), "marker file should be created");
}
#[test]
fn sidecar_hint_skips_when_marker_fresh() {
let tmp = TempDir::new().unwrap();
let marker = tmp.path().join(HOOK_HINT_MARKER);
std::fs::create_dir_all(marker.parent().unwrap()).unwrap();
std::fs::write(&marker, "").unwrap();
let mtime_before = std::fs::metadata(&marker).unwrap().modified().unwrap();
std::thread::sleep(std::time::Duration::from_millis(50));
maybe_emit_sidecar_hint(tmp.path());
let mtime_after = std::fs::metadata(&marker).unwrap().modified().unwrap();
assert_eq!(
mtime_before, mtime_after,
"marker mtime should not change when fresh"
);
}
fn make_input(
tool_name: &str,
file_path: Option<&str>,
pattern: Option<&str>,
cwd: &str,
) -> HookInput {
HookInput {
tool_name: Some(tool_name.to_string()),
tool_input: Some(HookToolInput {
file_path: file_path.map(|s| s.to_string()),
pattern: pattern.map(|s| s.to_string()),
path: None,
}),
cwd: Some(cwd.to_string()),
prompt: None,
}
}
}