aiscope 0.1.1

DevTools for your AI coding tools' memory. See what Cursor, Claude Code, and Copilot actually remember about your project — and where they disagree.
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Integration test: a Copilot-only repository (no Cursor, no Claude).
//!
//! Verifies aiscope still works fine when the user is on a single tool —
//! every Copilot subsystem (instructions / prompts / agents / AGENTS.md)
//! gets discovered and conflicts between sibling files are detected.

use aiscope::cmd::PipelineOptions;
use aiscope::model::{ConflictKind, Severity, Subsystem, Tool};
use aiscope::reason::ReasonMode;
use std::fs;
use std::path::Path;

fn copy_tree(src: &Path, dst: &Path) {
    if src.is_dir() {
        fs::create_dir_all(dst).unwrap();
        for e in fs::read_dir(src).unwrap().flatten() {
            copy_tree(&e.path(), &dst.join(e.file_name()));
        }
    } else {
        fs::create_dir_all(dst.parent().unwrap()).unwrap();
        fs::copy(src, dst).unwrap();
    }
}

#[test]
fn copilot_only_discovers_all_subsystems() {
    let tmp = tempfile::tempdir().unwrap();
    copy_tree(Path::new("tests/fixtures/copilot-only"), tmp.path());

    let bundle = aiscope::build_bundle(tmp.path(), PipelineOptions::default());

    // Every source must be Copilot.
    assert!(bundle.sources.iter().all(|s| s.tool == Tool::Copilot));

    // We should see all five subsystems represented (or at least the four
    // we wrote).
    let subs: std::collections::HashSet<_> = bundle.sources.iter().map(|s| s.subsystem).collect();
    assert!(
        subs.contains(&Subsystem::Instructions),
        "instructions missing"
    );
    assert!(subs.contains(&Subsystem::Prompts), "prompts missing");
    assert!(subs.contains(&Subsystem::Agents), "agents missing");

    // Path-scoped AGENTS.md must be discovered with a path_prefix.
    let agents_md = bundle
        .sources
        .iter()
        .find(|s| s.label.ends_with("AGENTS.md"))
        .expect("apps/web/AGENTS.md not found");
    assert_eq!(agents_md.subsystem, Subsystem::Agents);
    assert!(
        agents_md
            .scope
            .path_prefix
            .as_deref()
            .unwrap_or("")
            .contains("apps/web"),
        "path_prefix should be derived from file location, got {:?}",
        agents_md.scope.path_prefix
    );

    // applyTo from frontmatter must populate scope.globs.
    let py = bundle
        .sources
        .iter()
        .find(|s| s.label.ends_with("python.instructions.md"))
        .expect("python.instructions.md not found");
    assert!(py.scope.globs.iter().any(|g| g.contains("py")));
    let ts = bundle
        .sources
        .iter()
        .find(|s| s.label.ends_with("typescript.instructions.md"))
        .expect("typescript.instructions.md not found");
    assert!(ts.scope.globs.iter().any(|g| g.contains("ts")));

    // python applyTo:**/*.py vs typescript applyTo:**/*.ts → no overlap →
    // their snake_case (py) vs snake_case+camelCase ts clash should be
    // demoted to Low severity.
    let py_ts_conflict = bundle.conflicts.iter().any(|c| {
        c.severity == Severity::Low
            && matches!(c.kind, ConflictKind::Clash | ConflictKind::PolarityConflict)
    });
    let _ = py_ts_conflict; // informational

    // Root copilot-instructions (camelCase, applies everywhere) vs
    // typescript.instructions (snake_case, applies to **/*.ts) — overlap →
    // High severity.
    assert!(
        bundle
            .high_severity_conflicts()
            .any(|c| matches!(c.kind, ConflictKind::Clash | ConflictKind::PolarityConflict)),
        "expected a HIGH-severity Copilot-only naming clash. Got: {:#?}",
        bundle.conflicts
    );
}

#[test]
fn copilot_only_specific_mode_silences_prompt_vs_instructions() {
    let tmp = tempfile::tempdir().unwrap();
    copy_tree(Path::new("tests/fixtures/copilot-only"), tmp.path());

    let bundle = aiscope::build_bundle(
        tmp.path(),
        PipelineOptions {
            mode: ReasonMode::Specific,
            include_user: false,
        },
    );

    // In --specific mode, Prompts ↔ Instructions never conflict.
    for c in &bundle.conflicts {
        if let (Some(l), Some(r)) = (
            bundle.statements.get(c.left),
            bundle.statements.get(c.right),
        ) {
            let ls = bundle.sources.get(l.source_index).map(|s| s.subsystem);
            let rs = bundle.sources.get(r.source_index).map(|s| s.subsystem);
            let pair = (
                ls.unwrap_or(Subsystem::Instructions),
                rs.unwrap_or(Subsystem::Instructions),
            );
            assert!(
                !matches!(
                    pair,
                    (Subsystem::Prompts, Subsystem::Instructions)
                        | (Subsystem::Instructions, Subsystem::Prompts)
                ),
                "specific-mode should suppress prompt↔instruction clashes: {:?}",
                c
            );
        }
    }

    // Specific mode should still surface AgentToolMismatch even though it
    // silences cross-subsystem clashes — the agent excludes "bash" but
    // python.instructions says "use the bash tool".
    let mismatches: Vec<_> = bundle
        .conflicts
        .iter()
        .filter(|c| matches!(c.kind, ConflictKind::AgentToolMismatch))
        .collect();
    assert!(
        !mismatches.is_empty(),
        "expected AgentToolMismatch (agent.tools excludes bash; instruction says use bash tool). Got: {:#?}",
        bundle.conflicts
    );
}