use std::io::{BufRead, Read, Write};
use std::net::TcpStream;
use std::path::{Path, PathBuf};
use std::time::Duration;
use crate::cli::HookSubcommand;
use crate::domain::ControlStateDir;
const ADOPTION_LOG_FILE: &str = "hook-adoption.log";
fn process_control_state_dir() -> Option<ControlStateDir> {
crate::paths::process_control_state_placement()
.directory()
.cloned()
}
fn sidecar_descriptor_path(control_state_dir: &ControlStateDir) -> PathBuf {
crate::paths::control_state_path(control_state_dir, "sidecar/sessions")
}
const HTTP_TIMEOUT: Duration = Duration::from_millis(50);
const DAEMON_FALLBACK_DEADLINE: Duration = Duration::from_millis(500);
#[derive(serde::Deserialize, Default)]
pub 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>,
pub fail_open_reasons: std::collections::BTreeMap<String, usize>,
pub session_unknown: bool,
pub scope: Option<String>,
pub unscoped_rows: usize,
}
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<()> {
run_hook_with_input(parse_stdin_input(), subcommand)
}
pub fn run_hook_with_input(
input: HookInput,
subcommand: Option<&HookSubcommand>,
) -> anyhow::Result<()> {
run_hook_with_input_at(input, subcommand, process_control_state_dir())
}
#[doc(hidden)]
pub fn run_hook_with_input_at(
input: HookInput,
subcommand: Option<&HookSubcommand>,
control_state_dir: Option<ControlStateDir>,
) -> anyhow::Result<()> {
let verbose = is_hook_verbose();
let repo_root = std::env::current_dir().unwrap_or_default();
if matches!(subcommand, Some(HookSubcommand::PreTool)) {
let sidecar_active = control_state_dir
.as_ref()
.is_some_and(|state_dir| read_sidecar_endpoint(state_dir, &repo_root).is_ok());
if !sidecar_active {
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);
if workflow == HookWorkflow::PassThrough {
if verbose {
eprintln!("[symforge-hook] workflow=PassThrough — emitting fail-open");
}
println!("{}", fail_open_json(event_name));
return Ok(());
}
let Some((path, query)) = endpoint_for(resolved.as_ref(), &input) else {
if verbose {
eprintln!("[symforge-hook] no enrichment endpoint for this input — skipping");
}
println!("{}", fail_open_json(event_name));
return Ok(());
};
let sidecar_endpoint = control_state_dir
.as_ref()
.ok_or_else(|| {
std::io::Error::new(
std::io::ErrorKind::NotFound,
"process control state unavailable",
)
})
.and_then(|state_dir| read_sidecar_endpoint(state_dir, &repo_root))
.map(|identity| {
let lifetime = adoption_lifetime_label(&identity);
(
identity.port,
normalize_session_id(identity.session_id),
lifetime,
)
});
let session_id = sidecar_endpoint
.as_ref()
.ok()
.and_then(|(_, session_id, _)| session_id.clone());
let descriptor_lifetime = sidecar_endpoint
.as_ref()
.ok()
.and_then(|(_, _, lifetime)| lifetime.clone());
let row_lifetime = |row_session: Option<&str>| {
(row_session == session_id.as_deref())
.then_some(descriptor_lifetime.as_deref())
.flatten()
};
let (port, effective_session_id, used_daemon_fallback) = match sidecar_endpoint {
Ok((p, descriptor_session_id, _)) => {
if verbose {
eprintln!("[symforge-hook] read port file: port={p}");
}
(p, descriptor_session_id, false)
}
Err(e) => {
let port_file_path = control_state_dir
.as_ref()
.map(sidecar_descriptor_path)
.unwrap_or_default();
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, None) {
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(control_state_dir.as_ref());
if verbose {
eprintln!("[symforge-hook] outcome=NoSidecar reason=sidecar_port_missing");
}
record_hook_outcome_with_detail(
workflow,
HookOutcome::NoSidecar,
session_id.as_deref(),
row_lifetime(session_id.as_deref()),
Some(HookOutcomeDetail {
reason: "sidecar_port_missing",
searched_path: Some(&port_file_path.to_string_lossy()),
suggestion: Some("start_mcp_session"),
project_root: &repo_root.to_string_lossy(),
}),
);
println!("{}", fail_open_json(event_name));
return Ok(());
}
}
}
};
let initial_endpoint_is_daemon = effective_session_id.is_some();
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 Some(query) = append_caller_root(query) else {
if verbose {
eprintln!(
"[symforge-hook] project root is not valid UTF-8 — refusing enrichment authority and failing open"
);
}
record_hook_outcome_with_detail(
workflow,
HookOutcome::NoSidecar,
effective_session_id.as_deref(),
row_lifetime(effective_session_id.as_deref()),
Some(HookOutcomeDetail {
reason: "project_root_not_utf8",
searched_path: None,
suggestion: None,
project_root: &repo_root.to_string_lossy(),
}),
);
println!("{}", fail_open_json(event_name));
return Ok(());
};
let fallback_query = query.clone();
let (body, outcome, outcome_session_id) = match sync_enrichment_http_get(
port,
&request_path,
query,
) {
EnrichmentHttpResult::Success(b) => {
let initial_outcome = if used_daemon_fallback {
HookOutcome::DaemonFallback
} else {
HookOutcome::Routed
};
(b, initial_outcome, effective_session_id.clone())
}
initial_failure @ (EnrichmentHttpResult::IndexNotReady
| EnrichmentHttpResult::RootConflict
| EnrichmentHttpResult::HttpFailure(_)
| EnrichmentHttpResult::Unavailable) => {
let initial_index_not_ready =
matches!(initial_failure, EnrichmentHttpResult::IndexNotReady);
let initial_root_conflict =
matches!(initial_failure, EnrichmentHttpResult::RootConflict);
let initial_http_failure =
matches!(initial_failure, EnrichmentHttpResult::HttpFailure(_));
let port_file_path = control_state_dir
.as_ref()
.map(sidecar_descriptor_path)
.unwrap_or_default();
if verbose {
if initial_index_not_ready {
if initial_endpoint_is_daemon {
eprintln!("[symforge-hook] daemon index not ready — failing open");
} else {
eprintln!(
"[symforge-hook] index not ready — attempting daemon fallback before fail-open"
);
}
} else if initial_root_conflict {
if initial_endpoint_is_daemon {
eprintln!(
"[symforge-hook] daemon root conflict — attempting alternate daemon session"
);
} else {
eprintln!(
"[symforge-hook] sidecar root conflict — attempting daemon fallback before fail-open"
);
}
} else if initial_http_failure {
eprintln!(
"[symforge-hook] sidecar returned a live HTTP failure — attempting daemon fallback before fail-open"
);
} else {
let liveness = control_state_dir
.as_ref()
.map(|state_dir| {
crate::sidecar::port_file::read_sidecar_status(
state_dir,
"127.0.0.1",
Some(&repo_root),
)
.liveness
.as_str()
})
.unwrap_or("unavailable");
if initial_endpoint_is_daemon {
eprintln!(
"[symforge-hook] daemon HTTP request failed — liveness={liveness}, attempting alternate daemon session"
);
} else {
eprintln!(
"[symforge-hook] HTTP request failed — sidecar liveness={liveness}, \
attempting daemon fallback before fail-open"
);
}
}
}
let daemon_enriched = if initial_endpoint_is_daemon && initial_index_not_ready {
None
} else {
let excluded_session_id = initial_endpoint_is_daemon
.then_some(effective_session_id.as_deref())
.flatten();
match try_daemon_fallback(&repo_root, excluded_session_id) {
Some(fallback) => {
let fallback_session_id = fallback.session_id.clone();
let daemon_request_path = proxy_path(path, Some(&fallback.session_id));
if verbose {
eprintln!(
"[symforge-hook] daemon fallback (stale sidecar): \
port={}, session={}",
fallback.daemon_port, fallback.session_id
);
}
Some((
sync_enrichment_http_get_with_timeout(
fallback.daemon_port,
&daemon_request_path,
fallback_query,
DAEMON_FALLBACK_DEADLINE,
),
fallback_session_id,
))
}
None => None,
}
};
match daemon_enriched {
Some((EnrichmentHttpResult::Success(b), daemon_session_id)) => {
if verbose {
eprintln!(
"[symforge-hook] daemon fallback succeeded — \
sidecar dead/degraded, served enriched result via daemon"
);
}
(b, HookOutcome::DaemonFallback, Some(daemon_session_id))
}
Some((EnrichmentHttpResult::IndexNotReady, daemon_session_id)) => {
emit_live_refusal_fail_open(
workflow,
event_name,
Some(&daemon_session_id),
row_lifetime(Some(&daemon_session_id)),
"index_not_ready",
verbose,
&repo_root,
);
return Ok(());
}
Some((EnrichmentHttpResult::RootConflict, daemon_session_id)) => {
emit_live_refusal_fail_open(
workflow,
event_name,
Some(&daemon_session_id),
row_lifetime(Some(&daemon_session_id)),
"root_conflict",
verbose,
&repo_root,
);
return Ok(());
}
Some((EnrichmentHttpResult::HttpFailure(_), daemon_session_id)) => {
emit_live_refusal_fail_open(
workflow,
event_name,
Some(&daemon_session_id),
row_lifetime(Some(&daemon_session_id)),
"http_failure",
verbose,
&repo_root,
);
return Ok(());
}
Some((EnrichmentHttpResult::Unavailable, _)) | None if initial_index_not_ready => {
emit_live_refusal_fail_open(
workflow,
event_name,
effective_session_id.as_deref(),
row_lifetime(effective_session_id.as_deref()),
"index_not_ready",
verbose,
&repo_root,
);
return Ok(());
}
Some((EnrichmentHttpResult::Unavailable, _)) | None if initial_root_conflict => {
emit_live_refusal_fail_open(
workflow,
event_name,
effective_session_id.as_deref(),
row_lifetime(effective_session_id.as_deref()),
"root_conflict",
verbose,
&repo_root,
);
return Ok(());
}
Some((EnrichmentHttpResult::Unavailable, _)) | None if initial_http_failure => {
emit_live_refusal_fail_open(
workflow,
event_name,
effective_session_id.as_deref(),
row_lifetime(effective_session_id.as_deref()),
"http_failure",
verbose,
&repo_root,
);
return Ok(());
}
Some((EnrichmentHttpResult::Unavailable, _)) | None => {
if verbose {
eprintln!(
"[symforge-hook] daemon fallback unavailable — \
outcome=NoSidecar reason=sidecar_port_stale"
);
}
maybe_emit_sidecar_hint(control_state_dir.as_ref());
record_hook_outcome_with_detail(
workflow,
HookOutcome::NoSidecar,
effective_session_id.as_deref(),
row_lifetime(effective_session_id.as_deref()),
Some(HookOutcomeDetail {
reason: "sidecar_port_stale",
searched_path: Some(&port_file_path.to_string_lossy()),
suggestion: Some("restart_sidecar"),
project_root: &repo_root.to_string_lossy(),
}),
);
println!("{}", fail_open_json(event_name));
return Ok(());
}
}
}
};
if verbose {
eprintln!("[symforge-hook] outcome={}", outcome.label());
}
record_hook_outcome(
workflow,
outcome,
outcome_session_id.as_deref(),
row_lifetime(outcome_session_id.as_deref()),
);
println!("{}", success_json(event_name, &body));
Ok(())
}
fn emit_live_refusal_fail_open(
workflow: HookWorkflow,
event_name: &str,
session_id: Option<&str>,
lifetime: Option<&str>,
reason: &str,
verbose: bool,
repo_root: &std::path::Path,
) {
if verbose {
eprintln!("[symforge-hook] outcome=SidecarError reason={reason}");
}
record_hook_outcome_with_detail(
workflow,
HookOutcome::SidecarError,
session_id,
lifetime,
Some(HookOutcomeDetail {
reason,
searched_path: None,
suggestion: None,
project_root: &repo_root.to_string_lossy(),
}),
);
if event_name == "SessionStart" && reason == "index_not_ready" {
let project = repo_root
.file_name()
.map(|name| name.to_string_lossy().into_owned())
.unwrap_or_else(|| repo_root.display().to_string());
let notice = format!(
"symforge: {project}: {}.",
crate::protocol::format::INDEXING_IN_PROGRESS
);
println!("{}", success_json(event_name, ¬ice));
return;
}
println!("{}", fail_open_json(event_name));
}
const STDIN_READ_TIMEOUT_MS: u64 = 250;
pub(crate) fn parse_stdin_input() -> HookInput {
let (tx, rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
let stdin = std::io::stdin();
let mut stdin_json = String::new();
for line in stdin.lock().lines() {
match line {
Ok(l) => {
stdin_json.push_str(&l);
stdin_json.push('\n');
}
Err(_) => break,
}
}
let _ = tx.send(stdin_json);
});
match rx.recv_timeout(Duration::from_millis(STDIN_READ_TIMEOUT_MS)) {
Ok(stdin_json) => serde_json::from_str(&stdin_json).unwrap_or_default(),
Err(_) => HookInput::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 target = input
.tool_input
.as_ref()
.and_then(|ti| ti.file_path.as_deref().or(ti.path.as_deref()))
.unwrap_or("");
if is_outside_workspace(target, cwd) {
return String::new();
}
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 is_outside_workspace(target: &str, root: &str) -> bool {
if target.is_empty() || !std::path::Path::new(target).is_absolute() {
return false;
}
let root_norm = if root.is_empty() {
match std::env::current_dir() {
Ok(d) => normalize_path_for_match(&d),
Err(_) => return false,
}
} else {
normalize_path_for_match(std::path::Path::new(root))
};
if root_norm.is_empty() {
return false;
}
let target_norm = normalize_path_for_match(std::path::Path::new(target));
target_norm != root_norm && !target_norm.starts_with(&format!("{root_norm}/"))
}
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",
".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
}
fn is_plausible_symbol_name(pattern: &str) -> bool {
let mut chars = pattern.chars();
chars
.next()
.is_some_and(|c| c.is_ascii_alphabetic() || c == '_')
&& chars.all(|c| c.is_ascii_alphanumeric() || c == '_')
}
pub(crate) fn endpoint_for(
subcommand: Option<&HookSubcommand>,
input: &HookInput,
) -> Option<(&'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))
};
Some(("/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))
};
Some(("/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))
};
Some(("/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("");
if q.is_empty() || !is_plausible_symbol_name(q) {
return None;
}
Some(("/symbol-context", format!("name={}", url_encode(q))))
}
Some(HookSubcommand::SessionStart) => Some(("/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))
};
Some(("/prompt-context", query))
}
Some(HookSubcommand::PreTool) | None => None,
}
}
fn append_caller_root(query: String) -> Option<String> {
let cwd = std::env::current_dir().unwrap_or_default();
let root = std::fs::canonicalize(&cwd).unwrap_or(cwd);
append_caller_root_for_path(query, &root)
}
fn append_caller_root_for_path(query: String, root: &Path) -> Option<String> {
let encoded = url_encode(root.to_str()?);
Some(if query.is_empty() {
format!("caller_root={encoded}")
} else {
format!("{query}&caller_root={encoded}")
})
}
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_sidecar_endpoint(
control_state_dir: &ControlStateDir,
project_root: &Path,
) -> std::io::Result<crate::sidecar::port_file::SidecarEndpointIdentity> {
crate::sidecar::port_file::read_sidecar_endpoint_identity(
control_state_dir,
"127.0.0.1",
Some(project_root),
)
}
fn adoption_lifetime_label(
identity: &crate::sidecar::port_file::SidecarEndpointIdentity,
) -> Option<String> {
match (identity.daemon_started_at, identity.pid) {
(Some(epoch), _) => Some(format!("daemon:{epoch}")),
(None, Some(pid)) => Some(format!("pid:{pid}")),
(None, None) => None,
}
}
fn normalize_session_id(session_id: Option<String>) -> Option<String> {
session_id
.map(|session_id| session_id.trim().to_string())
.filter(|session_id| !session_id.is_empty())
}
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>,
lifetime: Option<&str>,
) {
record_hook_outcome_with_detail(workflow, outcome, session_id, lifetime, None);
}
fn record_hook_outcome_at(
control_state_dir: &ControlStateDir,
workflow: HookWorkflow,
outcome: HookOutcome,
session_id: Option<&str>,
lifetime: Option<&str>,
detail: Option<&HookOutcomeDetail<'_>>,
) {
let Some(workflow_name) = tracked_workflow_name(workflow) else {
return;
};
let row = adoption_row(session_id, lifetime, workflow_name, outcome.label(), detail);
let _ = append_adoption_row(&adoption_log_path(control_state_dir), &row);
}
struct DaemonFallbackResult {
daemon_port: u16,
session_id: String,
}
fn try_daemon_fallback(
repo_root: &Path,
excluded_session_id: Option<&str>,
) -> 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 projects: Vec<DaemonProjectEntry> = serde_json::from_str(&projects_json).ok()?;
let matching = projects
.iter()
.find(|project| daemon_project_matches_native_root(project, &canon_root))?;
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()
.filter(|session| {
session.project_id == matching.project_id
&& !session.session_id.trim().is_empty()
&& excluded_session_id.is_none_or(|excluded| session.session_id.trim() != excluded)
})
.max_by_key(|session| session.last_seen_at_unix_secs)?;
Some(DaemonFallbackResult {
daemon_port,
session_id: session.session_id.trim().to_string(),
})
}
#[derive(serde::Deserialize)]
struct DaemonProjectEntry {
project_id: String,
canonical_root: String,
session_count: usize,
}
fn daemon_project_matches_native_root(project: &DaemonProjectEntry, root: &Path) -> bool {
let expected_project_id = crate::daemon::project_key(root);
project.project_id == expected_project_id
&& crate::daemon::project_key(Path::new(&project.canonical_root)) == project.project_id
}
#[derive(serde::Deserialize)]
struct DaemonSessionEntry {
session_id: String,
project_id: String,
last_seen_at_unix_secs: u64,
}
#[derive(Debug, PartialEq, Eq)]
struct HttpResponse {
status_code: u16,
body: String,
}
#[derive(Debug, PartialEq, Eq)]
enum EnrichmentHttpResult {
Success(String),
IndexNotReady,
RootConflict,
HttpFailure(u16),
Unavailable,
}
fn normalize_path_text_for_match(path_text: &str, windows: bool) -> String {
let normalized = crate::daemon::normalized_path_text(path_text, windows);
let trimmed = normalized.trim_end_matches('/');
if windows {
trimmed.to_ascii_lowercase()
} else {
trimmed.to_string()
}
}
fn normalize_path_for_match(path: &Path) -> String {
normalize_path_text_for_match(&path.to_string_lossy(), cfg!(windows))
}
fn sync_http_response_with_timeout(
port: u16,
path: &str,
query: String,
timeout: Duration,
) -> anyhow::Result<HttpResponse> {
const MAX_HTTP_HEADER_BYTES: usize = 32 * 1024;
const MAX_HTTP_BODY_BYTES: usize = 8 * 1024 * 1024;
const MAX_HTTP_WIRE_BODY_BYTES: usize = 16 * 1024 * 1024;
let addr = format!("127.0.0.1:{port}");
let sock_addr: std::net::SocketAddr = addr.parse()?;
let deadline = std::time::Instant::now() + timeout;
let mut stream = TcpStream::connect_timeout(&sock_addr, timeout)?;
let request_path = if query.is_empty() {
path.to_string()
} else {
format!("{path}?{query}")
};
let auth_header = crate::daemon::resolve_daemon_auth_token()
.map(|token| format!("Authorization: Bearer {token}\r\n"))
.unwrap_or_default();
let request = format!(
"GET {request_path} HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\n{auth_header}Connection: close\r\n\r\n"
);
let remaining = deadline.saturating_duration_since(std::time::Instant::now());
anyhow::ensure!(!remaining.is_zero(), "HTTP request timed out");
stream.set_write_timeout(Some(remaining))?;
stream.write_all(request.as_bytes())?;
let mut response = Vec::new();
let mut chunk = [0_u8; 8192];
loop {
let remaining = deadline.saturating_duration_since(std::time::Instant::now());
anyhow::ensure!(!remaining.is_zero(), "HTTP response timed out");
stream.set_read_timeout(Some(remaining))?;
let count = match stream.read(&mut chunk) {
Ok(count) => count,
Err(error) if error.kind() == std::io::ErrorKind::Interrupted => continue,
Err(error) => return Err(error.into()),
};
if count > 0 {
response.extend_from_slice(&chunk[..count]);
anyhow::ensure!(
response.len() <= MAX_HTTP_HEADER_BYTES + MAX_HTTP_WIRE_BODY_BYTES,
"HTTP response exceeds size limit"
);
}
let Some(header_end) = response.windows(4).position(|bytes| bytes == b"\r\n\r\n") else {
anyhow::ensure!(
response.len() <= MAX_HTTP_HEADER_BYTES,
"HTTP headers exceed size limit"
);
anyhow::ensure!(count != 0, "malformed HTTP response: incomplete headers");
continue;
};
anyhow::ensure!(
header_end + 4 <= MAX_HTTP_HEADER_BYTES,
"HTTP headers exceed size limit"
);
let headers = std::str::from_utf8(&response[..header_end])?;
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"))?
.parse()
.map_err(|_| anyhow::anyhow!("non-numeric HTTP status code"))?;
let mut content_length = None;
let mut transfer_encoding = None;
for line in headers.lines().skip(1) {
let (name, value) = line
.split_once(':')
.ok_or_else(|| anyhow::anyhow!("malformed HTTP header"))?;
let value = value.trim();
if name.eq_ignore_ascii_case("content-length") {
let length: usize = value.parse()?;
anyhow::ensure!(
content_length.is_none_or(|previous| previous == length),
"conflicting HTTP content lengths"
);
content_length = Some(length);
} else if name.eq_ignore_ascii_case("transfer-encoding") {
anyhow::ensure!(
transfer_encoding.is_none(),
"duplicate HTTP transfer encoding"
);
transfer_encoding = Some(value);
}
}
anyhow::ensure!(
content_length.is_none() || transfer_encoding.is_none(),
"ambiguous HTTP body framing"
);
let body_start = header_end + 4;
let wire_body = &response[body_start..];
let body = if let Some(encoding) = transfer_encoding {
anyhow::ensure!(
encoding.eq_ignore_ascii_case("chunked"),
"unsupported HTTP transfer encoding"
);
decode_chunked_body(wire_body, MAX_HTTP_BODY_BYTES)?
} else if let Some(length) = content_length {
anyhow::ensure!(
length <= MAX_HTTP_BODY_BYTES,
"HTTP body exceeds size limit"
);
(wire_body.len() >= length).then(|| wire_body[..length].to_vec())
} else if count == 0 {
anyhow::ensure!(
wire_body.len() <= MAX_HTTP_BODY_BYTES,
"HTTP body exceeds size limit"
);
Some(wire_body.to_vec())
} else {
anyhow::ensure!(
wire_body.len() <= MAX_HTTP_BODY_BYTES,
"HTTP body exceeds size limit"
);
None
};
if let Some(body) = body {
let body = String::from_utf8(body)?;
anyhow::ensure!(
std::time::Instant::now() <= deadline,
"HTTP response timed out"
);
return Ok(HttpResponse { status_code, body });
}
anyhow::ensure!(count != 0, "malformed HTTP response: incomplete body");
}
}
fn sync_http_get_with_timeout(
port: u16,
path: &str,
query: String,
timeout: Duration,
) -> anyhow::Result<String> {
let response = sync_http_response_with_timeout(port, path, query, timeout)?;
if !(200..=299).contains(&response.status_code) {
anyhow::bail!("HTTP {} from {path}", response.status_code);
}
Ok(response.body)
}
fn classify_enrichment_response(response: HttpResponse) -> EnrichmentHttpResult {
match response.status_code {
200..=299 => EnrichmentHttpResult::Success(response.body),
409 => EnrichmentHttpResult::RootConflict,
503 => EnrichmentHttpResult::IndexNotReady,
status_code => EnrichmentHttpResult::HttpFailure(status_code),
}
}
fn sync_enrichment_http_get_with_timeout(
port: u16,
path: &str,
query: String,
timeout: Duration,
) -> EnrichmentHttpResult {
match sync_http_response_with_timeout(port, path, query, timeout) {
Ok(response) => classify_enrichment_response(response),
Err(_) => EnrichmentHttpResult::Unavailable,
}
}
fn decode_chunked_body(raw: &[u8], max_body_bytes: usize) -> anyhow::Result<Option<Vec<u8>>> {
let mut body = Vec::new();
let mut position = 0;
loop {
let Some(line_end) = raw[position..]
.windows(2)
.position(|bytes| bytes == b"\r\n")
else {
return Ok(None);
};
let size_line = &raw[position..position + line_end];
let size_text = std::str::from_utf8(size_line.split(|byte| *byte == b';').next().unwrap())?;
let size = usize::from_str_radix(size_text.trim(), 16)?;
position += line_end + 2;
if size == 0 {
let trailer = &raw[position..];
if trailer.starts_with(b"\r\n") || trailer.windows(4).any(|bytes| bytes == b"\r\n\r\n")
{
return Ok(Some(body));
}
return Ok(None);
}
anyhow::ensure!(
size <= max_body_bytes - body.len(),
"HTTP body exceeds size limit"
);
let Some(data_end) = position.checked_add(size) else {
anyhow::bail!("HTTP chunk size overflow");
};
let Some(frame_end) = data_end.checked_add(2) else {
anyhow::bail!("HTTP chunk size overflow");
};
if raw.len() < frame_end {
return Ok(None);
}
anyhow::ensure!(&raw[data_end..frame_end] == b"\r\n", "malformed HTTP chunk");
body.extend_from_slice(&raw[position..data_end]);
position = frame_end;
}
}
struct HookOutcomeDetail<'a> {
reason: &'a str,
searched_path: Option<&'a str>,
suggestion: Option<&'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 = "hook-hint-shown";
const HOOK_HINT_FRESHNESS: Duration = Duration::from_secs(30 * 60);
const SIDECAR_HINT_COMMAND: &str = "symforge init";
fn maybe_emit_sidecar_hint(control_state_dir: Option<&ControlStateDir>) {
let Some(control_state_dir) = control_state_dir else {
return;
};
let marker_path = crate::paths::control_state_path(control_state_dir, 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: {SIDECAR_HINT_COMMAND}");
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 matching control-state descriptor for {}.",
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>,
lifetime: Option<&str>,
detail: Option<HookOutcomeDetail<'_>>,
) {
let Some(control_state_dir) = process_control_state_dir() else {
return;
};
record_hook_outcome_at(
&control_state_dir,
workflow,
outcome,
session_id,
lifetime,
detail.as_ref(),
);
}
const ADOPTION_LOG_MAX_BYTES: u64 = 4 * 1024 * 1024;
fn adoption_row(
session_id: Option<&str>,
lifetime: Option<&str>,
workflow_name: &str,
outcome_label: &str,
detail: Option<&HookOutcomeDetail<'_>>,
) -> String {
let session = session_id
.map(str::trim)
.filter(|value| !value.is_empty())
.unwrap_or("-");
let lifetime = lifetime.unwrap_or("-");
let mut row = format!("{session}\t{workflow_name}\t{outcome_label}\tlifetime={lifetime}");
if let Some(d) = detail {
row.push_str(&format!("\treason={}", d.reason));
if let Some(path) = d.searched_path {
row.push_str(&format!("\tsearched_path={path}"));
}
if let Some(suggestion) = d.suggestion {
row.push_str(&format!("\tsuggestion={suggestion}"));
}
row.push_str(&format!("\tproject_root={}", d.project_root));
}
row.push('\n');
row
}
fn append_adoption_row(log_path: &Path, row: &str) -> std::io::Result<()> {
if let Some(parent) = log_path.parent() {
std::fs::create_dir_all(parent)?;
}
rotate_adoption_log_if_full(log_path);
let mut file = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open(log_path)?;
file.write_all(row.as_bytes())
}
const ADOPTION_LOG_ROTATE_LOCK_STALE: Duration = Duration::from_secs(30);
fn rotate_adoption_log_if_full(log_path: &Path) {
let is_full = |path: &Path| {
std::fs::metadata(path).is_ok_and(|meta| meta.len() >= ADOPTION_LOG_MAX_BYTES)
};
if !is_full(log_path) {
return;
}
let lock_path = log_path.with_extension("log.rotate-lock");
let acquire = || {
std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(&lock_path)
};
let lock = match acquire() {
Ok(lock) => lock,
Err(_) => {
let stale = std::fs::metadata(&lock_path)
.and_then(|meta| meta.modified())
.ok()
.and_then(|modified| modified.elapsed().ok())
.is_some_and(|age| age >= ADOPTION_LOG_ROTATE_LOCK_STALE);
if !stale {
return;
}
let _ = std::fs::remove_file(&lock_path);
match acquire() {
Ok(lock) => lock,
Err(_) => return,
}
}
};
if is_full(log_path) {
let _ = std::fs::rename(log_path, rotated_adoption_log_path(log_path));
}
drop(lock);
let _ = std::fs::remove_file(&lock_path);
}
fn rotated_adoption_log_path(log_path: &Path) -> PathBuf {
log_path.with_extension("log.1")
}
#[cfg(test)]
fn append_hook_adoption_event_with_detail(
log_path: &Path,
session_id: Option<&str>,
workflow_name: &str,
outcome_label: &str,
detail: Option<HookOutcomeDetail<'_>>,
) -> std::io::Result<()> {
let row = adoption_row(
session_id,
None,
workflow_name,
outcome_label,
detail.as_ref(),
);
append_adoption_row(log_path, &row)
}
#[cfg(test)]
fn append_hook_adoption_event(
log_path: &Path,
session_id: Option<&str>,
workflow_name: &str,
outcome_label: &str,
) -> std::io::Result<()> {
append_adoption_row(
log_path,
&adoption_row(session_id, None, workflow_name, outcome_label, None),
)
}
fn adoption_log_path(control_state_dir: &ControlStateDir) -> PathBuf {
crate::paths::control_state_path(control_state_dir, ADOPTION_LOG_FILE)
}
fn load_hook_adoption_snapshot_from_path(
log_path: &Path,
session_filter: Option<&str>,
lifetime_filter: Option<&str>,
) -> std::io::Result<HookAdoptionSnapshot> {
let rotated = std::fs::read_to_string(rotated_adoption_log_path(log_path)).unwrap_or_default();
let live = std::fs::read_to_string(log_path).unwrap_or_default();
let contents = rotated + &live;
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;
};
let mut lifetime = None;
let mut reason = None;
for column in parts {
if let Some(value) = column.strip_prefix("lifetime=") {
lifetime = Some(value);
} else if let Some(value) = column.strip_prefix("reason=") {
reason = Some(value);
}
}
if lifetime_filter.is_some() && lifetime == Some("-") {
snapshot.unscoped_rows += 1;
continue;
}
if let Some(filter) = session_filter
&& session_id != filter
{
continue;
}
if let Some(filter) = lifetime_filter
&& lifetime != Some(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);
if matches!(outcome, HookOutcome::NoSidecar | HookOutcome::SidecarError) {
let reason = reason.unwrap_or("unrecorded").to_string();
*snapshot.fail_open_reasons.entry(reason).or_default() += 1;
}
}
}
Ok(snapshot)
}
pub(crate) fn load_hook_adoption_snapshot(repo_root: Option<&Path>) -> HookAdoptionSnapshot {
let Some(control_state_dir) = process_control_state_dir() else {
return HookAdoptionSnapshot::default();
};
load_hook_adoption_snapshot_at(&control_state_dir, repo_root)
}
fn load_hook_adoption_snapshot_at(
control_state_dir: &ControlStateDir,
repo_root: Option<&Path>,
) -> HookAdoptionSnapshot {
let identity = crate::sidecar::port_file::read_sidecar_endpoint_identity(
control_state_dir,
"127.0.0.1",
repo_root,
)
.ok();
let Some((session, lifetime)) = identity.and_then(|identity| {
let lifetime = adoption_lifetime_label(&identity)?;
let session = normalize_session_id(identity.session_id).unwrap_or_else(|| "-".to_string());
Some((session, lifetime))
}) else {
return HookAdoptionSnapshot {
session_unknown: true,
..HookAdoptionSnapshot::default()
};
};
let mut snapshot = load_hook_adoption_snapshot_from_path(
&adoption_log_path(control_state_dir),
Some(&session),
Some(&lifetime),
)
.unwrap_or_default();
snapshot.scope = Some(format!("session {session}, {lifetime}"));
snapshot
}
fn sync_enrichment_http_get(port: u16, path: &str, query: String) -> EnrichmentHttpResult {
sync_enrichment_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 daemon_fallback_path_identity_treats_backslash_as_a_separator_only_on_windows() {
let literal = r"/work/a\b";
let nested = "/work/a/b";
assert_ne!(
normalize_path_text_for_match(literal, false),
normalize_path_text_for_match(nested, false)
);
assert_eq!(
normalize_path_text_for_match(literal, true),
normalize_path_text_for_match(nested, true)
);
}
#[cfg(unix)]
#[test]
fn daemon_fallback_path_matching_preserves_literal_backslash_components_on_unix() {
let root = TempDir::new().expect("create hook path identity fixture");
let literal = root.path().join(r"a\b");
let nested = root.path().join("a").join("b");
std::fs::create_dir_all(&literal).expect("create literal-backslash root");
std::fs::create_dir_all(&nested).expect("create nested root");
assert_ne!(
normalize_path_for_match(&literal),
normalize_path_for_match(&nested),
"daemon fallback must not route a nested Unix root to a literal-backslash project"
);
}
#[cfg(unix)]
#[test]
fn hook_authority_refuses_non_utf8_lossy_root_collisions() {
use std::os::unix::ffi::OsStringExt;
let native = PathBuf::from(std::ffi::OsString::from_vec(vec![b'a', 0xff, b'b']));
let lossy = PathBuf::from("a\u{fffd}b");
assert_eq!(native.to_string_lossy(), lossy.to_string_lossy());
let foreign = DaemonProjectEntry {
project_id: crate::daemon::project_key(&lossy),
canonical_root: lossy.to_str().expect("UTF-8 root").to_string(),
session_count: 1,
};
assert!(!daemon_project_matches_native_root(&foreign, &native));
assert!(append_caller_root_for_path(String::new(), &native).is_none());
}
#[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 enrichment_response_keeps_live_refusals_distinct_from_transport_failure() {
assert_eq!(
classify_enrichment_response(HttpResponse {
status_code: 503,
body: "partial index data must not be injected".to_string(),
}),
EnrichmentHttpResult::IndexNotReady
);
assert_eq!(
classify_enrichment_response(HttpResponse {
status_code: 409,
body: String::new(),
}),
EnrichmentHttpResult::RootConflict
);
assert_eq!(
classify_enrichment_response(HttpResponse {
status_code: 500,
body: String::new(),
}),
EnrichmentHttpResult::HttpFailure(500)
);
assert_eq!(
classify_enrichment_response(HttpResponse {
status_code: 404,
body: String::new(),
}),
EnrichmentHttpResult::HttpFailure(404)
);
assert_eq!(
classify_enrichment_response(HttpResponse {
status_code: 200,
body: "trusted context".to_string(),
}),
EnrichmentHttpResult::Success("trusted context".to_string())
);
}
fn fixture_http_response(response: Vec<u8>, hold_open: bool) -> anyhow::Result<HttpResponse> {
let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind fixture");
let port = listener.local_addr().expect("fixture address").port();
let server = std::thread::spawn(move || {
let (mut stream, _) = listener.accept().expect("accept hook request");
stream
.set_read_timeout(Some(Duration::from_millis(200)))
.expect("fixture request timeout");
let mut request = Vec::new();
let mut chunk = [0_u8; 1024];
while !request.windows(4).any(|bytes| bytes == b"\r\n\r\n") {
let count = stream.read(&mut chunk).expect("read hook request");
assert!(count > 0, "complete hook request");
request.extend_from_slice(&chunk[..count]);
}
stream.write_all(&response).expect("write fixture response");
stream.flush().expect("flush complete response");
if hold_open {
std::thread::sleep(Duration::from_millis(200));
} else {
stream
.shutdown(std::net::Shutdown::Write)
.expect("finish fixture response");
let _ = stream.read(&mut chunk);
}
});
let result = sync_http_response_with_timeout(
port,
"/v1/context",
String::new(),
Duration::from_millis(50),
);
server.join().expect("fixture server");
result
}
#[test]
fn framed_http_response_completes_before_connection_close() {
let response = b"HTTP/1.1 503 Service Unavailable\r\nContent-Length: 0\r\nConnection: keep-alive\r\n\r\n";
let result = fixture_http_response(response.to_vec(), true).expect("complete 503 frame");
assert_eq!(
classify_enrichment_response(result),
EnrichmentHttpResult::IndexNotReady
);
}
#[test]
fn framed_http_body_preserves_crlf_blank_lines_and_utf8() {
let body = "first\r\n\r\nživa\nlast";
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: keep-alive\r\n\r\n{body}",
body.len()
);
let result = fixture_http_response(response.into_bytes(), true).expect("complete body");
assert_eq!(result.body, body);
}
#[test]
fn framed_chunked_http_response_completes_before_connection_close() {
let response =
b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\nConnection: keep-alive\r\n\r\n5\r\nhello\r\n0\r\n\r\n";
let result = fixture_http_response(response.to_vec(), true).expect("complete chunks");
assert_eq!(result.body, "hello");
}
#[test]
fn incomplete_framed_http_response_is_rejected() {
let response = b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nhi";
assert!(fixture_http_response(response.to_vec(), false).is_err());
let response = b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nhi";
assert!(fixture_http_response(response.to_vec(), false).is_err());
}
#[test]
fn eof_delimited_http_response_preserves_body() {
let response = b"HTTP/1.1 200 OK\r\nConnection: close\r\n\r\nhello\r\nworld";
let result = fixture_http_response(response.to_vec(), false).expect("EOF body");
assert_eq!(result.body, "hello\r\nworld");
}
#[test]
fn unframed_open_http_response_respects_deadline() {
let response = b"HTTP/1.1 200 OK\r\nConnection: keep-alive\r\n\r\npartial";
assert!(fixture_http_response(response.to_vec(), true).is_err());
}
#[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).expect("routed endpoint");
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).expect("routed endpoint");
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).expect("routed endpoint");
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).expect("routed endpoint");
assert_eq!(path, "/symbol-context");
assert!(
query.contains("TODO"),
"Grep query must include pattern; got: {query}"
);
}
#[test]
fn test_endpoint_for_grep_regex_pattern_fails_open() {
for pattern in [
"compact|SYMFORGE_SURFACE",
"Tip:",
"fn .*_handler",
"two words",
"foo.bar",
"^anchor",
] {
let json = format!(
r#"{{"tool_name":"Grep","tool_input":{{"pattern":"{pattern}"}},"cwd":"/abs"}}"#
);
let input: HookInput = serde_json::from_str(&json).unwrap_or_default();
assert_eq!(
endpoint_for(Some(&HookSubcommand::Grep), &input),
None,
"pattern {pattern:?} must skip enrichment, not route to /health"
);
}
for pattern in ["classify_admission", "TODO", "_private", "Vec2d"] {
let json = format!(
r#"{{"tool_name":"Grep","tool_input":{{"pattern":"{pattern}"}},"cwd":"/abs"}}"#
);
let input: HookInput = serde_json::from_str(&json).unwrap_or_default();
let (path, _) =
endpoint_for(Some(&HookSubcommand::Grep), &input).expect("routed endpoint");
assert_eq!(
path, "/symbol-context",
"pattern {pattern:?} is a plausible symbol"
);
}
}
#[test]
fn test_endpoint_for_session_start_routes_to_repo_map() {
let input = HookInput::default();
let (path, query) =
endpoint_for(Some(&HookSubcommand::SessionStart), &input).expect("routed endpoint");
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).expect("routed endpoint");
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()
};
assert_eq!(endpoint_for(None, &input), None);
}
#[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).expect("routed endpoint");
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).expect("routed endpoint");
assert_eq!(path, "/impact");
}
#[test]
fn test_hook_subcommand_to_endpoint_grep_backward_compat() {
let input = HookInput::default();
assert_eq!(endpoint_for(Some(&HookSubcommand::Grep), &input), None);
}
#[test]
fn test_hook_subcommand_to_endpoint_session_start_backward_compat() {
let input = HookInput::default();
let (path, query) =
endpoint_for(Some(&HookSubcommand::SessionStart), &input).expect("routed endpoint");
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).expect("routed endpoint");
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_suggestion_read_outside_workspace_is_empty() {
let temp_target = std::env::temp_dir()
.join("claude")
.join("tasks")
.join("1.output");
let input = HookInput {
tool_name: Some("Read".to_string()),
tool_input: Some(HookToolInput {
file_path: Some(temp_target.to_string_lossy().into_owned()),
..Default::default()
}),
cwd: Some("/repo".to_string()),
..Default::default()
};
let s = pre_tool_suggestion(&input);
assert!(s.is_empty(), "should not hint outside the workspace: {s}");
}
#[test]
fn test_pre_tool_suggestion_read_in_repo_absolute_still_hints() {
let cwd = std::env::current_dir().unwrap();
let target = cwd.join("src").join("main.rs");
let input = HookInput {
tool_name: Some("Read".to_string()),
tool_input: Some(HookToolInput {
file_path: Some(target.to_string_lossy().into_owned()),
..Default::default()
}),
cwd: Some(cwd.to_string_lossy().into_owned()),
..Default::default()
};
let s = pre_tool_suggestion(&input);
assert!(
s.contains("get_file_context"),
"in-repo absolute read should still hint: {s}"
);
}
#[test]
fn test_pre_tool_suggestion_grep_outside_workspace_is_empty() {
let temp_dir = std::env::temp_dir().join("scratch");
let input = HookInput {
tool_name: Some("Grep".to_string()),
tool_input: Some(HookToolInput {
pattern: Some("helper".to_string()),
path: Some(temp_dir.to_string_lossy().into_owned()),
..Default::default()
}),
cwd: Some("/repo".to_string()),
..Default::default()
};
let s = pre_tool_suggestion(&input);
assert!(
s.is_empty(),
"should not hint for grep outside the workspace: {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_is_non_source_path_never_skips_an_indexed_language() {
for language in crate::domain::LanguageId::ALL {
if language == crate::domain::LanguageId::Text {
continue;
}
for ext in language.extensions() {
let path = format!("src/file.{ext}");
assert!(
!is_non_source_path(&path),
"{language:?} extension .{ext} is indexed but classified non-source"
);
}
}
}
#[test]
fn test_load_hook_adoption_snapshot_filters_to_current_session() {
let tmp = TempDir::new().unwrap();
let control_state = ControlStateDir::new(tmp.path().join(".symforge"));
let log_path = adoption_log_path(&control_state);
crate::sidecar::port_file::write_session_descriptor(
&control_state,
41_321,
Some("session-a"),
Some(tmp.path()),
None,
)
.unwrap();
let lifetime = format!("pid:{}", std::process::id());
let row = |session, workflow, outcome| {
append_adoption_row(
&log_path,
&adoption_row(Some(session), Some(&lifetime), workflow, outcome, None),
)
.unwrap()
};
row("session-a", "source-read", "routed");
row("session-a", "repo-start", "no-sidecar");
row("session-b", "source-search", "routed");
let snapshot = load_hook_adoption_snapshot_at(&control_state, 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"), None).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 test_adoption_loader_parses_extra_columns_and_tallies_reasons() {
let tmp = TempDir::new().unwrap();
let log_path = tmp.path().join("hook-adoption.log");
std::fs::write(
&log_path,
"s\tsource-read\tsidecar-error\tlifetime=pid:7\tfuture=1\treason=index_not_ready\tproject_root=/r\n\
s\tsource-read\tno-sidecar\n\
s\tsource-read\trouted\tlifetime=pid:7\tunknown_key=x\n",
)
.unwrap();
let snapshot = load_hook_adoption_snapshot_from_path(&log_path, Some("s"), None).unwrap();
assert_eq!(snapshot.source_read.total(), 3);
assert_eq!(snapshot.fail_open_reasons.get("index_not_ready"), Some(&1));
assert_eq!(snapshot.fail_open_reasons.get("unrecorded"), Some(&1));
let scoped =
load_hook_adoption_snapshot_from_path(&log_path, Some("s"), Some("pid:7")).unwrap();
assert_eq!(scoped.source_read.total(), 2);
}
#[test]
fn test_adoption_two_daemon_lifetimes_with_same_session_do_not_share_a_tally() {
let tmp = TempDir::new().unwrap();
let control_state = ControlStateDir::new(tmp.path().join(".symforge"));
let log_path = adoption_log_path(&control_state);
for (lifetime, outcome) in [
("daemon:100", "no-sidecar"),
("daemon:100", "no-sidecar"),
("daemon:200", "routed"),
] {
let row = adoption_row(
Some("session-1"),
Some(lifetime),
"source-read",
outcome,
None,
);
append_adoption_row(&log_path, &row).unwrap();
}
crate::sidecar::port_file::write_session_descriptor(
&control_state,
41_322,
Some("session-1"),
Some(tmp.path()),
Some(200),
)
.unwrap();
let snapshot = load_hook_adoption_snapshot_at(&control_state, Some(tmp.path()));
assert!(!snapshot.session_unknown);
assert_eq!(snapshot.source_read.routed, 1);
assert_eq!(
snapshot.source_read.no_sidecar, 0,
"the earlier lifetime leaked in"
);
assert_eq!(
snapshot.scope.as_deref(),
Some("session session-1, daemon:200")
);
}
#[test]
fn test_adoption_loader_reads_rotated_generation_and_reports_unscoped_rows() {
let tmp = TempDir::new().unwrap();
let log_path = tmp.path().join("hook-adoption.log");
let row = |session, lifetime, outcome| {
adoption_row(Some(session), lifetime, "source-read", outcome, None)
};
std::fs::write(
rotated_adoption_log_path(&log_path),
row("s", Some("pid:7"), "routed"),
)
.unwrap();
append_adoption_row(&log_path, &row("s", Some("pid:7"), "no-sidecar")).unwrap();
append_adoption_row(&log_path, &row("other", None, "daemon-fallback")).unwrap();
let snapshot =
load_hook_adoption_snapshot_from_path(&log_path, Some("s"), Some("pid:7")).unwrap();
assert_eq!(snapshot.source_read.routed, 1, "rotated rows were dropped");
assert_eq!(snapshot.source_read.no_sidecar, 1);
assert_eq!(snapshot.unscoped_rows, 1);
let rendered = crate::protocol::format::format_hook_adoption(&snapshot);
assert!(
rendered.contains("Rows with no recorded lifetime in the whole log: 1"),
"unscoped rows must be reported: {rendered}"
);
}
#[test]
fn test_adoption_rotation_moves_log_to_dot_one_at_cap() {
let tmp = TempDir::new().unwrap();
let log_path = tmp.path().join("hook-adoption.log");
let filler = "x".repeat(ADOPTION_LOG_MAX_BYTES as usize);
std::fs::write(&log_path, &filler).unwrap();
append_adoption_row(&log_path, "s\tsource-read\trouted\tlifetime=pid:7\n").unwrap();
assert_eq!(
std::fs::read_to_string(rotated_adoption_log_path(&log_path)).unwrap(),
filler
);
assert_eq!(
std::fs::read_to_string(&log_path).unwrap(),
"s\tsource-read\trouted\tlifetime=pid:7\n"
);
}
#[test]
fn test_adoption_concurrent_writers_crossing_the_cap_lose_no_rows() {
let tmp = TempDir::new().unwrap();
let log_path = tmp.path().join("hook-adoption.log");
let filler = format!("{}\n", "x".repeat(ADOPTION_LOG_MAX_BYTES as usize - 64));
std::fs::write(&log_path, &filler).unwrap();
const WRITERS: usize = 8;
const ROWS: usize = 50;
std::thread::scope(|scope| {
for writer in 0..WRITERS {
let log_path = &log_path;
scope.spawn(move || {
for row in 0..ROWS {
let session = format!("w{writer}-{row}");
let line = adoption_row(
Some(&session),
Some("pid:1"),
"source-read",
"routed",
None,
);
append_adoption_row(log_path, &line).unwrap();
}
});
}
});
let rotated = std::fs::read_to_string(rotated_adoption_log_path(&log_path)).unwrap();
let live = std::fs::read_to_string(&log_path).unwrap();
assert!(
rotated.starts_with(&filler),
"the filled generation must be the rotated one"
);
let mut sessions: Vec<&str> = rotated
.lines()
.chain(live.lines())
.filter(|line| line.contains('\t'))
.map(|line| line.split('\t').next().unwrap())
.collect();
sessions.sort_unstable();
sessions.dedup();
assert_eq!(
sessions.len(),
WRITERS * ROWS,
"rows were lost across live + .1"
);
assert!(!log_path.with_extension("log.rotate-lock").exists());
}
#[test]
fn test_adoption_rotation_breaks_a_stale_lock_but_respects_a_fresh_one() {
let tmp = TempDir::new().unwrap();
let log_path = tmp.path().join("hook-adoption.log");
let lock_path = log_path.with_extension("log.rotate-lock");
let filler = "x".repeat(ADOPTION_LOG_MAX_BYTES as usize);
std::fs::write(&log_path, &filler).unwrap();
std::fs::write(&lock_path, "").unwrap();
append_adoption_row(&log_path, "a\tsource-read\trouted\n").unwrap();
assert!(!rotated_adoption_log_path(&log_path).exists());
let old = std::time::SystemTime::now() - ADOPTION_LOG_ROTATE_LOCK_STALE * 2;
std::fs::File::options()
.write(true)
.open(&lock_path)
.unwrap()
.set_modified(old)
.unwrap();
append_adoption_row(&log_path, "b\tsource-read\trouted\n").unwrap();
assert!(rotated_adoption_log_path(&log_path).exists());
assert_eq!(
std::fs::read_to_string(&log_path).unwrap(),
"b\tsource-read\trouted\n"
);
assert!(!lock_path.exists());
}
#[test]
fn test_adoption_unresolvable_session_yields_empty_unknown_tally() {
let tmp = TempDir::new().unwrap();
let control_state = ControlStateDir::new(tmp.path().join(".symforge"));
let log_path = adoption_log_path(&control_state);
append_hook_adoption_event(&log_path, Some("session-a"), "source-read", "routed").unwrap();
append_hook_adoption_event(&log_path, None, "source-read", "no-sidecar").unwrap();
let snapshot = load_hook_adoption_snapshot_at(&control_state, Some(tmp.path()));
assert!(snapshot.session_unknown);
assert_eq!(snapshot.total_attempts(), 0);
}
#[test]
fn test_adoption_concurrent_writers_produce_no_torn_rows() {
let tmp = TempDir::new().unwrap();
let log_path = tmp.path().join("hook-adoption.log");
let long_root = "r".repeat(2_000);
std::thread::scope(|scope| {
for writer in 0..8 {
let log_path = &log_path;
let long_root = &long_root;
scope.spawn(move || {
for _ in 0..50 {
let session = format!("w{writer}");
let detail = HookOutcomeDetail {
reason: "http_failure",
searched_path: None,
suggestion: None,
project_root: long_root,
};
let row = adoption_row(
Some(&session),
Some("pid:1"),
"source-read",
"sidecar-error",
Some(&detail),
);
append_adoption_row(log_path, &row).unwrap();
}
});
}
});
let contents = std::fs::read_to_string(&log_path).unwrap();
let lines: Vec<&str> = contents.lines().collect();
assert_eq!(lines.len(), 400);
for line in lines {
let columns: Vec<&str> = line.split('\t').collect();
assert_eq!(columns.len(), 6, "torn row: {line:.80}");
assert!(columns[0].starts_with('w'), "torn row: {line:.80}");
assert_eq!(columns[5].len(), "project_root=".len() + 2_000);
}
}
#[test]
fn test_health_hook_adoption_metric_pins_published_contract() {
let tmp = TempDir::new().unwrap();
let control = ControlStateDir::new(tmp.path().join("control"));
let log_path = adoption_log_path(&control);
append_hook_adoption_event(&log_path, Some("sess-live"), "repo-start", "routed").unwrap();
append_hook_adoption_event(&log_path, Some("sess-live"), "prompt-context", "routed")
.unwrap();
assert_eq!(adoption_log_path(&control), log_path);
let snapshot = load_hook_adoption_snapshot_from_path(&log_path, Some("sess-live"), None)
.expect("load adoption snapshot");
assert_eq!(snapshot.total_routed(), 2);
assert_eq!(snapshot.total_attempts(), 2);
assert_eq!(snapshot.total_fail_open(), 0);
let rendered = crate::protocol::format::format_hook_adoption(&snapshot);
assert!(
rendered.contains("── Hook Adoption ──"),
"missing section header: {rendered}"
);
assert!(
rendered.contains("Owned workflows routed: 2/2 (100%)"),
"published contract string missing: {rendered}"
);
assert!(
rendered.contains("Fail-open outcomes: 0"),
"should show zero fail-open when all routed: {rendered}"
);
assert!(
rendered.contains("Repo start: routed 1"),
"missing per-workflow line for repo-start: {rendered}"
);
assert!(
rendered.contains("Prompt context: routed 1"),
"missing per-workflow line for prompt-context: {rendered}"
);
assert!(
rendered.contains("First repo start: routed"),
"first-repo-start outcome must render: {rendered}"
);
}
#[test]
fn test_health_hook_adoption_metric_flags_silent_failure_when_all_fail_open() {
let tmp = TempDir::new().unwrap();
let control = ControlStateDir::new(tmp.path().join("control"));
let log_path = adoption_log_path(&control);
append_hook_adoption_event(&log_path, Some("sess-down"), "source-read", "no-sidecar")
.unwrap();
append_hook_adoption_event(&log_path, Some("sess-down"), "prompt-context", "no-sidecar")
.unwrap();
let snapshot = load_hook_adoption_snapshot_from_path(&log_path, Some("sess-down"), None)
.expect("load adoption snapshot");
let rendered = crate::protocol::format::format_hook_adoption(&snapshot);
assert!(
rendered.contains("Owned workflows routed: 0/2 (0%)"),
"degraded metric must visibly read 0/2, not be absent: {rendered}"
);
assert!(
rendered.contains("Fail-open outcomes: 2 (no sidecar 2"),
"fail-open breakdown must surface the real cause: {rendered}"
);
assert!(
rendered.contains("⚠ All hook attempts failed open"),
"user-facing warning must render when no workflow routed: {rendered}"
);
}
#[test]
fn test_record_hook_outcome_writes_to_adoption_log_file_constant() {
let tmp = TempDir::new().unwrap();
let control = ControlStateDir::new(tmp.path().join("control"));
record_hook_outcome_at(
&control,
HookWorkflow::SourceRead,
HookOutcome::Routed,
Some("sess-wireup"),
None,
None,
);
let log_path = adoption_log_path(&control);
assert!(
log_path.exists(),
"record_hook_outcome must create {ADOPTION_LOG_FILE} in control state; missing at {}",
log_path.display()
);
let contents = std::fs::read_to_string(&log_path).expect("log readable");
assert!(
contents.contains("sess-wireup\tsource-read\trouted"),
"log must contain the tab-separated routed event; got: {contents:?}"
);
}
#[allow(unsafe_code)] #[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());
}
#[allow(unsafe_code)] #[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);
}
#[allow(unsafe_code)] #[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 = HookOutcomeDetail {
reason: "sidecar_port_missing",
searched_path: Some("/repo/.symforge/sidecar.port"),
suggestion: Some("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 = HookOutcomeDetail {
reason: "sidecar_port_stale",
searched_path: Some("/repo/.symforge/sidecar.port"),
suggestion: Some("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 control = ControlStateDir::new(tmp.path().join("control"));
let marker = crate::paths::control_state_path(&control, HOOK_HINT_MARKER);
assert!(!marker.exists());
maybe_emit_sidecar_hint(Some(&control));
assert!(marker.exists(), "marker file should be created");
}
#[test]
fn sidecar_hint_skips_when_marker_fresh() {
let tmp = TempDir::new().unwrap();
let control = ControlStateDir::new(tmp.path().join("control"));
let marker = crate::paths::control_state_path(&control, 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(Some(&control));
let mtime_after = std::fs::metadata(&marker).unwrap().modified().unwrap();
assert_eq!(
mtime_before, mtime_after,
"marker mtime should not change when fresh"
);
}
#[test]
fn sidecar_hint_command_parses_as_valid_cli_invocation() {
use clap::Parser;
let args: Vec<&str> = SIDECAR_HINT_COMMAND.split_whitespace().collect();
assert_eq!(
args.first().copied(),
Some("symforge"),
"hint command must invoke the symforge binary"
);
crate::cli::Cli::try_parse_from(args).unwrap_or_else(|e| {
panic!("sidecar hint command `{SIDECAR_HINT_COMMAND}` must parse as a valid CLI invocation, got: {e}")
});
}
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,
}
}
}