asurada 0.3.1

//! Claude Code hook 통합.
//!
//! Claude Code 의 hook 시스템은 도구 호출/프롬프트 제출 등 핵심 시점에
//! 외부 명령을 실행한다. 그 외부 명령으로 `asurada hook check <event>` 가
//! 호출되면, 우리는 stdin JSON 페이로드를 받아 brain.db 에 기록하고
//! decision JSON 을 stdout 에 출력한다.
//!
//! Phase 1 (현재): passthrough — 모든 호출을 기록만 하고 차단하지 않음.
//!     Anthropic 이 hook 스펙을 바꾸어도 이 layer 만 갈아끼우면 됨.
//! Phase 2+: intervention/redo 신호 도출 → advice 큐로 surface.

use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::io::Read;

pub mod settings;

/// 의존성/빌드 산출물/캐시 디렉토리 — 안에서 일어난 도구 호출은 사용자 *의도* 가
/// 아니라 부수 효과. 패턴 분석을 흐리게 만들므로 hook event 기록에서 제외.
///
/// Path 어디든 매치 — `/node_modules/` 가 경로 중간에 있어도 catch.
/// trailing slash 로 정확한 segment 매칭 (예: "/target/" 만, "/target_arch/" 는 X).
pub const NOISE_PATH_SEGMENTS: &[&str] = &[
    "/node_modules/",
    "/target/",
    "/dist/",
    "/build/",
    "/.git/",
    "/.next/",
    "/.nuxt/",
    "/.svelte-kit/",
    "/.cache/",
    "/.venv/",
    "/venv/",
    "/__pycache__/",
    "/coverage/",
    "/.turbo/",
    "/.parcel-cache/",
    "/.pytest_cache/",
    "/.mypy_cache/",
    "/.gradle/",
    "/.idea/",
    "/.vscode/",
];

pub fn is_noise_path(p: &str) -> bool {
    NOISE_PATH_SEGMENTS.iter().any(|seg| p.contains(seg))
}

/// raw payload 에서 도구가 만진 파일 경로를 추출해 *절대 경로* 로 반환.
///
/// 다양한 도구 입력 형태를 흡수:
///   - `tool_input.file_path` (Edit/Write/Read)
///   - `tool_input.notebook_path` (NotebookEdit)
///   - `tool_input.file_paths[0]` (드물게 배열형)
///
/// 상대경로면 cwd 와 join. 정규화는 path 매칭에 영향 없으므로 그대로 둠.
fn extract_tool_file_path(raw: &serde_json::Value, cwd: Option<&str>) -> Option<String> {
    let input = raw.get("tool_input")?;
    let candidate = input
        .get("file_path")
        .and_then(|v| v.as_str())
        .or_else(|| input.get("notebook_path").and_then(|v| v.as_str()))
        .or_else(|| {
            input
                .get("file_paths")
                .and_then(|v| v.as_array())
                .and_then(|arr| arr.first())
                .and_then(|v| v.as_str())
        })?;
    let p = std::path::Path::new(candidate);
    if p.is_absolute() {
        Some(candidate.to_string())
    } else if let Some(c) = cwd {
        Some(
            std::path::Path::new(c)
                .join(p)
                .to_string_lossy()
                .into_owned(),
        )
    } else {
        Some(candidate.to_string())
    }
}

/// Claude Code 가 보내는 hook 이벤트 종류.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HookEvent {
    PreToolUse,
    PostToolUse,
    UserPromptSubmit,
    Stop,
    SessionStart,
    SessionEnd,
}

impl HookEvent {
    pub fn parse(s: &str) -> Option<Self> {
        match s {
            "pre-tool-use" | "PreToolUse" => Some(Self::PreToolUse),
            "post-tool-use" | "PostToolUse" => Some(Self::PostToolUse),
            "user-prompt-submit" | "UserPromptSubmit" => Some(Self::UserPromptSubmit),
            "stop" | "Stop" => Some(Self::Stop),
            "session-start" | "SessionStart" => Some(Self::SessionStart),
            "session-end" | "SessionEnd" => Some(Self::SessionEnd),
            _ => None,
        }
    }

    /// brain.db `events.event_type` 에 저장될 문자열.
    pub fn as_event_type(self) -> &'static str {
        match self {
            Self::PreToolUse => "hook.tool_pre",
            Self::PostToolUse => "hook.tool_post",
            Self::UserPromptSubmit => "hook.user_prompt",
            Self::Stop => "hook.stop",
            Self::SessionStart => "hook.session_start",
            Self::SessionEnd => "hook.session_end",
        }
    }

    /// Claude Code settings.json 의 hooks.<key> 표기.
    pub fn as_settings_key(self) -> &'static str {
        match self {
            Self::PreToolUse => "PreToolUse",
            Self::PostToolUse => "PostToolUse",
            Self::UserPromptSubmit => "UserPromptSubmit",
            Self::Stop => "Stop",
            Self::SessionStart => "SessionStart",
            Self::SessionEnd => "SessionEnd",
        }
    }

    /// `asurada hook check <arg>` 의 arg 토큰.
    pub fn as_cli_arg(self) -> &'static str {
        match self {
            Self::PreToolUse => "pre-tool-use",
            Self::PostToolUse => "post-tool-use",
            Self::UserPromptSubmit => "user-prompt-submit",
            Self::Stop => "stop",
            Self::SessionStart => "session-start",
            Self::SessionEnd => "session-end",
        }
    }
}

#[cfg(test)]
mod noise_path_tests {
    use super::*;

    #[test]
    fn flags_dependency_dirs() {
        assert!(is_noise_path("/Users/x/proj/node_modules/react/index.js"));
        assert!(is_noise_path("/proj/foo/node_modules/lib/a.ts"));
    }

    #[test]
    fn flags_build_outputs_and_caches() {
        assert!(is_noise_path("/proj/target/debug/foo"));
        assert!(is_noise_path("/proj/dist/bundle.js"));
        assert!(is_noise_path("/proj/.git/HEAD"));
        assert!(is_noise_path("/proj/.next/cache/x"));
        assert!(is_noise_path("/proj/__pycache__/foo.pyc"));
    }

    #[test]
    fn does_not_flag_normal_paths() {
        assert!(!is_noise_path("/proj/src/main.rs"));
        assert!(!is_noise_path("/proj/website/src/App.tsx"));
        // segment boundary — "/target_arch/" 는 "/target/" 아님
        assert!(!is_noise_path("/proj/target_arch/x"));
        // 부분 문자열도 아님 (".gitlab" 은 ".git/" 아님)
        assert!(!is_noise_path("/proj/.gitlab-ci.yml"));
    }
}

/// Claude Code 가 stdin 으로 넘겨주는 JSON. 스키마는 향후 변할 수 있어
/// 모든 필드를 Optional 로 두고 raw 본문을 그대로 보존한다.
#[derive(Debug, Clone, Deserialize, Default)]
pub struct HookPayload {
    #[serde(default)]
    pub session_id: Option<String>,
    #[serde(default)]
    pub cwd: Option<String>,
    #[serde(default)]
    pub tool_name: Option<String>,
    #[serde(default)]
    pub prompt: Option<String>,
}

/// Claude Code 에 돌려주는 결정. 비워서 출력하면 정상 진행.
#[derive(Debug, Clone, Serialize, Default)]
pub struct HookDecision {
    /// "allow" | "deny" | "ask" — 미지정 시 정상 진행.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub decision: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    /// UserPromptSubmit 한정 — 컨텍스트에 prepend 될 텍스트.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub additional_context: Option<String>,
}

/// `asurada hook check <event>` 의 진입점.
///
/// 실패는 절대 사용자 작업을 끊으면 안 된다. 모든 에러를 삼키고
/// 빈 decision 을 출력한 뒤 0 으로 종료한다.
pub fn cmd_check(event: HookEvent) -> Result<()> {
    let mut buf = String::new();
    let read_ok = std::io::stdin().read_to_string(&mut buf).is_ok();

    let raw_value: serde_json::Value =
        serde_json::from_str(&buf).unwrap_or_else(|_| serde_json::json!({}));
    let payload: HookPayload = if read_ok && !buf.trim().is_empty() {
        serde_json::from_str(&buf).unwrap_or_default()
    } else {
        HookPayload::default()
    };

    if let Err(e) = record_event(event, &payload, &buf) {
        tracing::warn!("[hook] record failed: {}", e);
    }

    let decision = match event {
        HookEvent::PreToolUse => evaluate_gate(&payload, &raw_value).unwrap_or_default(),
        HookEvent::UserPromptSubmit => build_prompt_context(&payload).unwrap_or_default(),
        _ => HookDecision::default(),
    };

    println!(
        "{}",
        serde_json::to_string(&decision).unwrap_or_else(|_| "{}".into())
    );
    Ok(())
}

/// UserPromptSubmit 시점 추가 컨텍스트 — signature 매칭 시에만 발화.
/// 매칭 항목이 없으면 default (빈 컨텍스트). blanket dump 금지.
fn build_prompt_context(payload: &HookPayload) -> Result<HookDecision> {
    use crate::adapter::limits::ADDITIONAL_CONTEXT_MAX_LINES;

    let prompt = match payload.prompt.as_deref() {
        Some(p) if !p.trim().is_empty() => p,
        _ => return Ok(HookDecision::default()),
    };

    let cfg = match crate::config::Config::load(&crate::paths::config_file()?) {
        Ok(c) => c,
        Err(_) => return Ok(HookDecision::default()),
    };
    let conn = crate::db::open(&crate::paths::brain_db()?)?;
    let signature = crate::signals::task_signature(prompt);
    let project = payload
        .cwd
        .as_deref()
        .and_then(|cwd| {
            crate::db::project::resolve_canonical_name(&conn, &cfg.user.id, cwd)
                .ok()
                .flatten()
                .or_else(|| {
                    std::path::Path::new(cwd)
                        .file_name()
                        .and_then(|s| s.to_str())
                        .map(String::from)
                })
        })
        .unwrap_or_else(|| "_".into());

    let mut lines: Vec<String> = Vec::new();

    // 1) signature 매칭 활성 하네스
    let matched = crate::db::pattern::list_by_signature(&conn, &cfg.user.id, signature)?;
    if !matched.is_empty() {
        lines.push("**[Asurada 메모리]** 누적 패턴 매칭 — 이전에 처리한 적 있음:".into());
        for h in matched.iter().take(3) {
            lines.push(format!(
                "- 하네스 *{}* (project={}, used {}x): {}",
                h.title, h.project, h.usage_count, h.description
            ));
            for fp in &h.file_paths {
                lines.push(format!("  ↳ 워크플로우: `{}`", fp));
            }
        }
        // 사용 추적 — 다음 진화에 활용 (5c).
        for h in matched.iter().take(3) {
            let _ = crate::db::pattern::record_use(&conn, &h.id);
            let _ = crate::db::event::insert(
                &conn,
                crate::db::event::EventInput {
                    user_id: cfg.user.id.clone(),
                    project: project.clone(),
                    event_type: "signal.harness_use".into(),
                    path: None,
                    payload: serde_json::json!({
                        "harness_id": h.id,
                        "slug": h.slug,
                        "trigger": "signature_match",
                        "signature": signature,
                    }),
                },
            );
        }
    }

    // 2) 매칭 하네스가 없으면, 단순 반복 안내 (≥ 2회) + stuck 힌트
    if matched.is_empty() {
        let (count_inclusive, _) = crate::signals::count_prior_with_signature(
            &conn,
            &cfg.user.id,
            &project,
            signature,
            30,
        )?;
        let prior = count_inclusive.saturating_sub(1);
        if prior >= 5 {
            // [Layer C — stuck hint] 5회 이상 반복 + 하네스 없음 → 적극 권유
            lines.push(format!(
                "**[Asurada]** 이 작업을 {}회 반복하고 있어요. 하네스로 묶어두면 \
                 다음에 더 일관되게 처리됩니다 — `asurada pattern propose --threshold {} --days 7`",
                prior,
                prior.min(5)
            ));
        } else if prior >= 2 {
            lines.push(format!(
                "**[Asurada 메모리]** 사용자가 이 작업을 {}회 반복했음. \
                 이전 접근을 회상해 일관성 유지.",
                prior
            ));
        }
    }

    // 3) [Layer C — bridge] 직전 prompt 가 30분 내 *다른* 프로젝트였다면 안내
    if let Ok(Some(bridge)) = detect_project_bridge(&conn, &cfg.user.id, &project) {
        lines.push(bridge);
    }

    // 4) [Layer C — brief recall] 이 프로젝트의 최신 brief 메모리 한 줄 인용
    if let Ok(Some(recall)) = recall_recent_brief(&conn, &cfg.user.id, &project) {
        lines.push(recall);
    }

    if lines.is_empty() {
        return Ok(HookDecision::default());
    }

    let truncated: Vec<String> = lines
        .into_iter()
        .take(ADDITIONAL_CONTEXT_MAX_LINES)
        .collect();
    let context = truncated.join("\n");

    // 주입 사실 자체를 신호로 기록 — 노이즈 평가에 활용.
    let _ = crate::db::event::insert(
        &conn,
        crate::db::event::EventInput {
            user_id: cfg.user.id,
            project,
            event_type: "signal.context_injection".into(),
            path: None,
            payload: serde_json::json!({
                "signature": signature,
                "lines": truncated.len(),
            }),
        },
    );

    Ok(HookDecision {
        decision: None,
        reason: None,
        additional_context: Some(context),
    })
}

/// PreToolUse 시점에 ~/.asurada/gates.json 의 규칙을 평가해 결정 반환.
fn evaluate_gate(payload: &HookPayload, raw: &serde_json::Value) -> Result<HookDecision> {
    let home = dirs::home_dir().ok_or_else(|| anyhow::anyhow!("no home"))?;
    let gates_path = home.join(".asurada/gates.json");
    let rules = crate::adapter::claude_code::load_gate_rules(&gates_path)?;
    if rules.is_empty() {
        return Ok(HookDecision::default());
    }
    let tool_input = raw
        .get("tool_input")
        .cloned()
        .unwrap_or_else(|| serde_json::json!({}));
    let Some(rule) =
        crate::adapter::claude_code::match_gate(&rules, payload.tool_name.as_deref(), &tool_input)
    else {
        return Ok(HookDecision::default());
    };
    Ok(HookDecision {
        decision: Some(rule.decision),
        reason: Some(format!("[Asurada] {}", rule.reason)),
        additional_context: None,
    })
}

/// [Layer C — bridge] 직전 hook.user_prompt (30분 내) 가 *다른* 프로젝트였으면
/// 그 프로젝트의 마지막 prompt 한 줄 미리 회상시켜 컨텍스트 전환 부드럽게.
fn detect_project_bridge(
    conn: &rusqlite::Connection,
    user_id: &str,
    current_project: &str,
) -> Result<Option<String>> {
    let cutoff = (chrono::Utc::now() - chrono::Duration::minutes(30)).to_rfc3339();
    let mut stmt = conn.prepare(
        r#"SELECT project, json_extract(payload, '$.prompt')
           FROM events
           WHERE user_id = ?1 AND event_type = 'hook.user_prompt'
             AND created_at > ?2
             AND project != ?3
           ORDER BY created_at DESC LIMIT 1"#,
    )?;
    let row: Option<(String, Option<String>)> = stmt
        .query_row(rusqlite::params![user_id, cutoff, current_project], |r| {
            Ok((r.get(0)?, r.get(1)?))
        })
        .ok();
    let Some((prev_project, prev_prompt)) = row else {
        return Ok(None);
    };
    let preview: String = prev_prompt.unwrap_or_default().chars().take(70).collect();
    if preview.is_empty() {
        return Ok(None);
    }
    Ok(Some(format!(
        "**[Asurada — 프로젝트 전환]** 직전 30분 내 *{}* 에서 \"{}\" 작업 중. \
         그쪽 미해결 사항이 있으면 잊지 말 것.",
        prev_project, preview
    )))
}

/// [Layer C — brief recall] 현재 프로젝트의 최신 brief 메모리 첫 문장만 인용.
fn recall_recent_brief(
    conn: &rusqlite::Connection,
    user_id: &str,
    project: &str,
) -> Result<Option<String>> {
    let cutoff = (chrono::Utc::now() - chrono::Duration::hours(36)).to_rfc3339();
    let text: Option<String> = conn
        .query_row(
            r#"SELECT text FROM memories
               WHERE user_id = ?1 AND project = ?2
                 AND source = 'asurada'
                 AND json_extract(metadata, '$.kind') = 'brief'
                 AND created_at > ?3
                 AND deleted_at IS NULL
               ORDER BY created_at DESC LIMIT 1"#,
            rusqlite::params![user_id, project, cutoff],
            |r| r.get(0),
        )
        .ok();
    let Some(t) = text else {
        return Ok(None);
    };
    // 첫 문장 (.) 까지만 — 충분.
    let first_sentence = t
        .lines()
        .find(|l| !l.trim().is_empty() && !l.starts_with('['))
        .unwrap_or("");
    let preview: String = first_sentence.chars().take(180).collect();
    if preview.is_empty() {
        return Ok(None);
    }
    Ok(Some(format!("**[Asurada — 어제 brief]** {}", preview)))
}

/// brain.db 에 hook 이벤트 기록 + 도출 신호 기록 (best-effort).
fn record_event(event: HookEvent, payload: &HookPayload, raw: &str) -> Result<()> {
    let cfg_path = crate::paths::config_file()?;
    let cfg = match crate::config::Config::load(&cfg_path) {
        Ok(c) => c,
        Err(_) => {
            // asurada init 전이면 조용히 넘어감.
            return Ok(());
        }
    };

    let raw_value: serde_json::Value =
        serde_json::from_str(raw).unwrap_or_else(|_| serde_json::json!({}));

    // 도구 이벤트의 file_path 가 noise (node_modules / target / .git 등) 안이면
    // 의미 신호가 아니므로 통째로 스킵. 사용자 prompt 는 어디서든 유효.
    if matches!(event, HookEvent::PreToolUse | HookEvent::PostToolUse) {
        let file_path = raw_value
            .get("tool_input")
            .and_then(|t| t.get("file_path"))
            .and_then(|v| v.as_str());
        if let Some(fp) = file_path {
            if is_noise_path(fp) {
                return Ok(());
            }
        }
    }

    let conn = crate::db::open(&crate::paths::brain_db()?)?;

    // canonical project 결정 — Devist 가 어디서든 여러 프로젝트를 관리할 수 있어야
    // 하므로 단순 cwd 기반은 부정확. 우선순위:
    //   1. tool_input.file_path 가 등록 project path 의 하위면 그 project (가장 정확)
    //   2. cwd 가 등록 project path 의 하위면 그 project
    //   3. cwd basename (legacy fallback) — 등록 안 된 cwd
    //   4. "_"
    //
    // file_path 가 상대경로면 cwd 와 join 해 절대화 후 매칭.
    let tool_file_path: Option<String> =
        if matches!(event, HookEvent::PreToolUse | HookEvent::PostToolUse) {
            extract_tool_file_path(&raw_value, payload.cwd.as_deref())
        } else {
            None
        };
    let project = tool_file_path
        .as_deref()
        .and_then(|fp| {
            crate::db::project::resolve_canonical_name(&conn, &cfg.user.id, fp)
                .ok()
                .flatten()
        })
        .or_else(|| {
            payload.cwd.as_deref().and_then(|cwd| {
                crate::db::project::resolve_canonical_name(&conn, &cfg.user.id, cwd)
                    .ok()
                    .flatten()
                    .or_else(|| {
                        std::path::Path::new(cwd)
                            .file_name()
                            .and_then(|s| s.to_str())
                            .map(String::from)
                    })
            })
        })
        .unwrap_or_else(|| "_".into());

    // UserPromptSubmit 이면 signature 미리 계산해서 payload 에 동봉.
    // 후속 redo 검색이 SQL 한 줄로 끝남.
    let signature = if event == HookEvent::UserPromptSubmit {
        payload
            .prompt
            .as_deref()
            .map(crate::signals::task_signature)
    } else {
        None
    };

    let payload_json = serde_json::json!({
        "session_id": payload.session_id,
        "tool_name": payload.tool_name,
        "prompt": payload.prompt,
        "cwd": payload.cwd,
        "signature": signature,
        "raw": raw_value,
    });

    crate::db::event::insert(
        &conn,
        crate::db::event::EventInput {
            user_id: cfg.user.id.clone(),
            project: project.clone(),
            event_type: event.as_event_type().to_string(),
            path: None,
            payload: payload_json,
        },
    )?;

    // 신호 도출 — Phase 2: prompt 분석. Phase 5c: skill Read 감지.
    if event == HookEvent::UserPromptSubmit {
        if let Some(prompt) = payload.prompt.as_deref() {
            crate::signals::detect_and_record(&conn, &cfg.user.id, &project, prompt, signature)?;
        }
    }
    if event == HookEvent::PreToolUse {
        // raw_value 에서 tool_input.file_path 추출해 skill 경로 매칭 시도.
        let file_path = raw_value
            .get("tool_input")
            .and_then(|t| t.get("file_path"))
            .and_then(|v| v.as_str());
        if let Ok(Some(harness_id)) = crate::pattern::detect_skill_read(
            &conn,
            &cfg.user.id,
            &project,
            payload.tool_name.as_deref(),
            file_path,
        ) {
            let _ = crate::db::pattern::record_use(&conn, &harness_id);
            let _ = crate::db::event::insert(
                &conn,
                crate::db::event::EventInput {
                    user_id: cfg.user.id.clone(),
                    project: project.clone(),
                    event_type: "signal.harness_use".into(),
                    path: file_path.map(String::from),
                    payload: serde_json::json!({
                        "harness_id": harness_id,
                        "trigger": "skill_read",
                    }),
                },
            );
        }
    }

    Ok(())
}