1b47b45566
The install_hook() function is about hook infrastructure setup, not daemon runtime. Move it to hook.rs where it belongs alongside the hook execution logic. - Move install_hook() from daemon.rs to hook.rs - Update caller in daemon.rs to use crate::subconscious:🪝:install_hook() - Update caller in cli/admin.rs to use crate::subconscious:🪝:install_hook() This improves module boundaries: daemon.rs now only contains daemon runtime and admin commands, while hook.rs contains all hook-related functionality.
312 lines
11 KiB
Rust
312 lines
11 KiB
Rust
// hook.rs — Claude Code session hook: context injection + agent orchestration
|
|
//
|
|
// Called on each UserPromptSubmit via the poc-hook binary. Handles
|
|
// context loading, chunking, seen-set management, and delegates
|
|
// agent orchestration to AgentCycleState.
|
|
|
|
use std::collections::HashSet;
|
|
use std::fs;
|
|
use std::io::Write;
|
|
use std::path::Path;
|
|
use std::process::Command;
|
|
use std::time::Instant;
|
|
|
|
pub use crate::session::HookSession;
|
|
pub use super::subconscious::*;
|
|
|
|
const CHUNK_SIZE: usize = 9000;
|
|
|
|
/// Run the hook logic on parsed JSON input. Returns output to inject.
|
|
pub fn run_hook(input: &str) -> String {
|
|
let Some(session) = HookSession::from_json(input) else { return String::new() };
|
|
hook(&session)
|
|
}
|
|
|
|
fn chunk_context(ctx: &str, max_bytes: usize) -> Vec<String> {
|
|
let mut sections: Vec<String> = Vec::new();
|
|
let mut current = String::new();
|
|
|
|
for line in ctx.lines() {
|
|
if line.starts_with("--- ") && line.ends_with(" ---") && !current.is_empty() {
|
|
sections.push(std::mem::take(&mut current));
|
|
}
|
|
if !current.is_empty() {
|
|
current.push('\n');
|
|
}
|
|
current.push_str(line);
|
|
}
|
|
if !current.is_empty() {
|
|
sections.push(current);
|
|
}
|
|
|
|
let mut chunks: Vec<String> = Vec::new();
|
|
let mut chunk = String::new();
|
|
for section in sections {
|
|
if !chunk.is_empty() && chunk.len() + section.len() + 1 > max_bytes {
|
|
chunks.push(std::mem::take(&mut chunk));
|
|
}
|
|
if !chunk.is_empty() {
|
|
chunk.push('\n');
|
|
}
|
|
chunk.push_str(§ion);
|
|
}
|
|
if !chunk.is_empty() {
|
|
chunks.push(chunk);
|
|
}
|
|
chunks
|
|
}
|
|
|
|
fn save_pending_chunks(dir: &Path, session_id: &str, chunks: &[String]) {
|
|
let chunks_dir = dir.join(format!("chunks-{}", session_id));
|
|
let _ = fs::remove_dir_all(&chunks_dir);
|
|
if chunks.is_empty() { return; }
|
|
fs::create_dir_all(&chunks_dir).ok();
|
|
for (i, chunk) in chunks.iter().enumerate() {
|
|
let path = chunks_dir.join(format!("{:04}", i));
|
|
fs::write(path, chunk).ok();
|
|
}
|
|
}
|
|
|
|
fn pop_pending_chunk(dir: &Path, session_id: &str) -> Option<String> {
|
|
let chunks_dir = dir.join(format!("chunks-{}", session_id));
|
|
if !chunks_dir.exists() { return None; }
|
|
|
|
let mut entries: Vec<_> = fs::read_dir(&chunks_dir).ok()?
|
|
.flatten()
|
|
.filter(|e| e.file_type().map(|t| t.is_file()).unwrap_or(false))
|
|
.collect();
|
|
entries.sort_by_key(|e| e.file_name());
|
|
|
|
let first = entries.first()?;
|
|
let content = fs::read_to_string(first.path()).ok()?;
|
|
fs::remove_file(first.path()).ok();
|
|
|
|
if fs::read_dir(&chunks_dir).ok().map(|mut d| d.next().is_none()).unwrap_or(true) {
|
|
fs::remove_dir(&chunks_dir).ok();
|
|
}
|
|
|
|
Some(content)
|
|
}
|
|
|
|
fn generate_cookie() -> String {
|
|
uuid::Uuid::new_v4().as_simple().to_string()[..12].to_string()
|
|
}
|
|
|
|
fn parse_seen_line(line: &str) -> &str {
|
|
line.split_once('\t').map(|(_, key)| key).unwrap_or(line)
|
|
}
|
|
|
|
pub fn load_seen(dir: &Path, session_id: &str) -> HashSet<String> {
|
|
let path = dir.join(format!("seen-{}", session_id));
|
|
if path.exists() {
|
|
fs::read_to_string(&path)
|
|
.unwrap_or_default()
|
|
.lines()
|
|
.filter(|s| !s.is_empty())
|
|
.map(|s| parse_seen_line(s).to_string())
|
|
.collect()
|
|
} else {
|
|
HashSet::new()
|
|
}
|
|
}
|
|
|
|
fn mark_seen(dir: &Path, session_id: &str, key: &str, seen: &mut HashSet<String>) {
|
|
if !seen.insert(key.to_string()) { return; }
|
|
let path = dir.join(format!("seen-{}", session_id));
|
|
if let Ok(mut f) = fs::OpenOptions::new().create(true).append(true).open(path) {
|
|
let ts = chrono::Local::now().format("%Y-%m-%dT%H:%M:%S");
|
|
writeln!(f, "{}\t{}", ts, key).ok();
|
|
}
|
|
}
|
|
|
|
/// Standalone entry point for the Claude Code hook path.
|
|
/// Loads saved state, runs cycles, saves state back.
|
|
pub fn run_agent_cycles(session: &HookSession) -> AgentCycleOutput {
|
|
let mut state = AgentCycleState::new(&session.session_id);
|
|
state.restore(&SavedAgentState::load(&session.session_id));
|
|
state.trigger(session);
|
|
state.save(&session.session_id);
|
|
state.last_output
|
|
}
|
|
|
|
fn hook(session: &HookSession) -> String {
|
|
let start_time = Instant::now();
|
|
|
|
let mut out = String::new();
|
|
let is_compaction = crate::transcript::detect_new_compaction(
|
|
&session.state_dir, &session.session_id, &session.transcript_path,
|
|
);
|
|
let cookie_path = session.path("cookie");
|
|
let is_first = !cookie_path.exists();
|
|
|
|
let log_dir = dirs::home_dir().unwrap_or_default().join(".consciousness/logs");
|
|
fs::create_dir_all(&log_dir).ok();
|
|
let log_path = log_dir.join(format!("hook-{}", session.session_id));
|
|
let Ok(mut log_f) = fs::OpenOptions::new().create(true).append(true).open(log_path) else { return Default::default(); };
|
|
let ts = chrono::Local::now().format("%Y-%m-%dT%H:%M:%S");
|
|
let _ = writeln!(log_f, "\n=== {} ({}) {} bytes ===", ts, session.hook_event, out.len());
|
|
|
|
let _ = writeln!(log_f, "is_first {is_first} is_compaction {is_compaction}");
|
|
|
|
if is_first || is_compaction {
|
|
if is_compaction {
|
|
fs::rename(&session.path("seen"), &session.path("seen-prev")).ok();
|
|
} else {
|
|
fs::remove_file(&session.path("seen")).ok();
|
|
fs::remove_file(&session.path("seen-prev")).ok();
|
|
}
|
|
fs::remove_file(&session.path("returned")).ok();
|
|
|
|
if is_first {
|
|
fs::write(&cookie_path, generate_cookie()).ok();
|
|
}
|
|
|
|
if let Ok(output) = Command::new("poc-memory").args(["admin", "load-context"]).output() {
|
|
if output.status.success() {
|
|
let ctx = String::from_utf8_lossy(&output.stdout).to_string();
|
|
if !ctx.trim().is_empty() {
|
|
let mut ctx_seen = session.seen();
|
|
for line in ctx.lines() {
|
|
if line.starts_with("--- ") && line.ends_with(" ---") {
|
|
let inner = &line[4..line.len() - 4];
|
|
if let Some(paren) = inner.rfind(" (") {
|
|
let key = inner[..paren].trim();
|
|
mark_seen(&session.state_dir, &session.session_id, key, &mut ctx_seen);
|
|
}
|
|
}
|
|
}
|
|
|
|
let chunks = chunk_context(&ctx, CHUNK_SIZE);
|
|
|
|
if let Some(first) = chunks.first() {
|
|
out.push_str(first);
|
|
}
|
|
save_pending_chunks(&session.state_dir, &session.session_id, &chunks[1..]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if let Some(chunk) = pop_pending_chunk(&session.state_dir, &session.session_id) {
|
|
out.push_str(&chunk);
|
|
} else {
|
|
let cfg = crate::config::get();
|
|
if cfg.surface_hooks.iter().any(|h| h == &session.hook_event) {
|
|
let cycle_output = run_agent_cycles(&session);
|
|
out.push_str(&format_agent_output(&cycle_output));
|
|
}
|
|
}
|
|
|
|
let _ = write!(log_f, "{}", out);
|
|
|
|
let duration = (Instant::now() - start_time).as_secs_f64();
|
|
let _ = writeln!(log_f, "\nran in {duration:.2}s");
|
|
|
|
out
|
|
}
|
|
|
|
/// Install memory-search and poc-hook into Claude Code settings.json.
|
|
///
|
|
/// Hook layout:
|
|
/// UserPromptSubmit: memory-search (10s), poc-hook (5s)
|
|
/// PostToolUse: poc-hook (5s)
|
|
/// Stop: poc-hook (5s)
|
|
pub fn install_hook() -> Result<(), String> {
|
|
use std::path::PathBuf;
|
|
|
|
let home = std::env::var("HOME").map_err(|e| format!("HOME: {}", e))?;
|
|
let exe = std::env::current_exe()
|
|
.map_err(|e| format!("current_exe: {}", e))?;
|
|
let settings_path = PathBuf::from(&home).join(".claude/settings.json");
|
|
|
|
let memory_search = exe.with_file_name("memory-search");
|
|
let poc_hook = exe.with_file_name("poc-hook");
|
|
|
|
let mut settings: serde_json::Value = if settings_path.exists() {
|
|
let content = fs::read_to_string(&settings_path)
|
|
.map_err(|e| format!("read settings: {}", e))?;
|
|
serde_json::from_str(&content)
|
|
.map_err(|e| format!("parse settings: {}", e))?
|
|
} else {
|
|
serde_json::json!({})
|
|
};
|
|
|
|
let obj = settings.as_object_mut().ok_or("settings not an object")?;
|
|
let hooks_obj = obj.entry("hooks")
|
|
.or_insert_with(|| serde_json::json!({}))
|
|
.as_object_mut().ok_or("hooks not an object")?;
|
|
|
|
let mut changed = false;
|
|
|
|
// Helper: ensure a hook binary is present in an event's hook list
|
|
let ensure_hook = |hooks_obj: &mut serde_json::Map<String, serde_json::Value>,
|
|
event: &str,
|
|
binary: &Path,
|
|
timeout: u32,
|
|
changed: &mut bool| {
|
|
if !binary.exists() {
|
|
eprintln!("Warning: {} not found — skipping", binary.display());
|
|
return;
|
|
}
|
|
let cmd = binary.to_string_lossy().to_string();
|
|
let name = binary.file_name().unwrap().to_string_lossy().to_string();
|
|
|
|
let event_array = hooks_obj.entry(event)
|
|
.or_insert_with(|| serde_json::json!([{"hooks": []}]))
|
|
.as_array_mut().unwrap();
|
|
if event_array.is_empty() {
|
|
event_array.push(serde_json::json!({"hooks": []}));
|
|
}
|
|
let inner = event_array[0]
|
|
.as_object_mut().unwrap()
|
|
.entry("hooks")
|
|
.or_insert_with(|| serde_json::json!([]))
|
|
.as_array_mut().unwrap();
|
|
|
|
// Remove legacy load-memory.sh
|
|
let before = inner.len();
|
|
inner.retain(|h| {
|
|
let c = h.get("command").and_then(|c| c.as_str()).unwrap_or("");
|
|
!c.contains("load-memory")
|
|
});
|
|
if inner.len() < before {
|
|
eprintln!("Removed load-memory.sh from {event}");
|
|
*changed = true;
|
|
}
|
|
|
|
let already = inner.iter().any(|h| {
|
|
h.get("command").and_then(|c| c.as_str())
|
|
.is_some_and(|c| c.contains(&name))
|
|
});
|
|
|
|
if !already {
|
|
inner.push(serde_json::json!({
|
|
"type": "command",
|
|
"command": cmd,
|
|
"timeout": timeout
|
|
}));
|
|
*changed = true;
|
|
eprintln!("Installed {name} in {event}");
|
|
}
|
|
};
|
|
|
|
// UserPromptSubmit: memory-search + poc-hook
|
|
ensure_hook(hooks_obj, "UserPromptSubmit", &memory_search, 10, &mut changed);
|
|
ensure_hook(hooks_obj, "UserPromptSubmit", &poc_hook, 5, &mut changed);
|
|
|
|
// PostToolUse + Stop: poc-hook only
|
|
ensure_hook(hooks_obj, "PostToolUse", &poc_hook, 5, &mut changed);
|
|
ensure_hook(hooks_obj, "Stop", &poc_hook, 5, &mut changed);
|
|
|
|
if changed {
|
|
let json = serde_json::to_string_pretty(&settings)
|
|
.map_err(|e| format!("serialize settings: {}", e))?;
|
|
fs::write(&settings_path, json)
|
|
.map_err(|e| format!("write settings: {}", e))?;
|
|
eprintln!("Updated {}", settings_path.display());
|
|
} else {
|
|
eprintln!("All hooks already installed in {}", settings_path.display());
|
|
}
|
|
|
|
Ok(())
|
|
}
|