claudix 0.2.0

Local semantic search plugin for Claude Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;

use tempfile::TempDir;

pub struct TestFixture {
    _tempdir: TempDir,
    root: PathBuf,
}

impl TestFixture {
    pub fn new(name: &str) -> std::io::Result<Self> {
        let source = fixture_source(name);
        let tempdir = tempfile::tempdir()?;
        let root = tempdir.path().join(name);
        copy_dir_recursive(&source, &root)?;
        init_git_repo(&root)?;

        Ok(Self {
            _tempdir: tempdir,
            root,
        })
    }

    /// Like `new`, but skips the 5 git subprocess calls. Use this in tests that
    /// don't exercise git enumeration — saves ~50-100 ms per fixture construction.
    // This file is `include!`d into several test modules; not every copy uses
    // every helper.
    #[allow(dead_code)]
    pub fn without_git(name: &str) -> std::io::Result<Self> {
        let source = fixture_source(name);
        let tempdir = tempfile::tempdir()?;
        let root = tempdir.path().join(name);
        copy_dir_recursive(&source, &root)?;

        Ok(Self {
            _tempdir: tempdir,
            root,
        })
    }

    pub fn root(&self) -> &Path {
        &self.root
    }

    /// Decompose into `(TempDir, root_path)` so the caller can store the
    /// `TempDir` guard without keeping the whole `TestFixture` alive.
    #[allow(dead_code)]
    pub fn into_parts(self) -> (TempDir, PathBuf) {
        (self._tempdir, self.root)
    }
}

fn fixture_source(name: &str) -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("tests")
        .join("fixtures")
        .join(name)
}

fn copy_dir_recursive(source: &Path, destination: &Path) -> std::io::Result<()> {
    fs::create_dir_all(destination)?;

    for entry in fs::read_dir(source)? {
        let entry = entry?;
        let source_path = entry.path();
        let destination_path = destination.join(entry.file_name());
        let file_type = entry.file_type()?;

        if file_type.is_dir() {
            copy_dir_recursive(&source_path, &destination_path)?;
        } else {
            fs::copy(&source_path, &destination_path)?;
        }
    }

    Ok(())
}

fn init_git_repo(root: &Path) -> std::io::Result<()> {
    run(root, ["init"])?;
    run(root, ["config", "user.name", "Test User"])?;
    run(root, ["config", "user.email", "test@example.com"])?;
    run(root, ["add", "."])?;
    run(root, ["commit", "-m", "fixture"])?;
    Ok(())
}

fn run<const N: usize>(root: &Path, args: [&str; N]) -> std::io::Result<()> {
    // Neutralise the developer's global/system git config for the throwaway
    // fixture repo. The user's `commit.gpgsign = true` otherwise routes every
    // fixture commit through gpg-agent (eddsa signing), adding 10-30s per
    // fixture and intermittently failing under parallel test load. Pointing
    // both config scopes at a path that does not exist makes git read them as
    // empty (portable across platforms); the local `user.name`/`user.email`
    // we set still land in `.git/config`.
    let empty_config = root.join(".claudix-test-empty-gitconfig");
    // `output()` (not `status()`) so fixture git chatter — init hints, commit
    // summaries — never pollutes test output; stderr surfaces only on failure.
    let output = Command::new("git")
        .current_dir(root)
        .env("GIT_CONFIG_GLOBAL", &empty_config)
        .env("GIT_CONFIG_SYSTEM", &empty_config)
        .args(args)
        .output()?;
    if output.status.success() {
        return Ok(());
    }

    Err(std::io::Error::other(format!(
        "git command failed: {:?}: {}",
        args,
        String::from_utf8_lossy(&output.stderr)
    )))
}