aft/
lib.rs

1#![allow(
2    clippy::collapsible_if,
3    clippy::collapsible_match,
4    clippy::double_ended_iterator_last,
5    clippy::int_plus_one,
6    clippy::large_enum_variant,
7    clippy::len_without_is_empty,
8    clippy::let_and_return,
9    clippy::manual_contains,
10    clippy::manual_pattern_char_comparison,
11    clippy::manual_repeat_n,
12    clippy::manual_strip,
13    clippy::manual_unwrap_or_default,
14    clippy::map_clone,
15    clippy::iter_kv_map,
16    clippy::needless_borrow,
17    clippy::needless_borrows_for_generic_args,
18    clippy::needless_range_loop,
19    clippy::new_without_default,
20    clippy::obfuscated_if_else,
21    clippy::ptr_arg,
22    clippy::question_mark,
23    clippy::same_item_push,
24    clippy::should_implement_trait,
25    clippy::single_match,
26    clippy::too_many_arguments,
27    clippy::type_complexity,
28    clippy::unnecessary_sort_by,
29    clippy::unnecessary_cast,
30    clippy::unnecessary_lazy_evaluations,
31    clippy::unnecessary_map_or
32)]
33
34// ## Note on `.unwrap()` / `.expect()` usage
35//
36// The remaining `.unwrap()` and `.expect()` calls in `src/` are in:
37// - **Tree-sitter query operations** (parser.rs, zoom.rs, extract.rs, inline.rs,
38//   outline.rs): These operate on AFT's own compiled grammars and query patterns, which
39//   are compile-time constants. Pattern captures and node kinds are guaranteed to exist.
40// - **Checkpoint serialization** (checkpoint.rs): serde_json::to_value on known-good
41//   HashMap<PathBuf, String> types cannot fail.
42// - **lib.rs main loop**: JSON parsing of stdin lines — a malformed line is logged and
43//   skipped, not unwrapped.
44//
45// All production command handlers that process user/agent input return Result or
46// Response::error instead of panicking. Confirmed zero .unwrap()/.expect() in
47// production error paths as of v0.6.3 audit.
48
49pub mod ast_grep_hints;
50pub mod ast_grep_lang;
51pub mod backup;
52pub mod bash_background;
53pub mod bash_permissions;
54pub mod bash_rewrite;
55pub mod cache_freshness;
56pub mod callgraph;
57pub mod calls;
58pub mod checkpoint;
59pub mod commands;
60pub mod compress;
61pub mod config;
62pub mod context;
63pub mod db;
64pub mod edit;
65pub mod error;
66pub mod extract;
67pub mod format;
68pub mod fs_lock;
69pub mod fuzzy_match;
70pub mod grep_executor;
71pub mod harness;
72pub mod imports;
73pub mod indent;
74pub mod inspect;
75pub mod language;
76pub mod log_ctx;
77pub mod lsp;
78pub mod lsp_hints;
79pub mod migrate_storage;
80pub mod parser;
81pub mod pattern_compile;
82pub mod protocol;
83pub mod query_shape;
84pub mod search_index;
85pub mod semantic_index;
86pub mod symbol_cache_disk;
87pub mod symbols;
88pub mod tool_path;
89pub mod url_fetch;
90// Compiled on all platforms so cross-platform unit tests in
91// `commands::bash::try_spawn_with_fallback` can exercise the retry
92// decision logic without a real Windows runtime. The module itself only
93// uses portable APIs; only its callers are Windows-gated.
94pub mod windows_shell;
95
96#[cfg(test)]
97mod tests {
98    use super::*;
99    use config::Config;
100    use error::AftError;
101    use protocol::{RawRequest, Response};
102
103    // --- Protocol serialization ---
104
105    #[test]
106    fn raw_request_deserializes_ping() {
107        let json = r#"{"id":"1","command":"ping"}"#;
108        let req: RawRequest = serde_json::from_str(json).unwrap();
109        assert_eq!(req.id, "1");
110        assert_eq!(req.command, "ping");
111        assert!(req.lsp_hints.is_none());
112    }
113
114    #[test]
115    fn raw_request_deserializes_echo_with_params() {
116        let json = r#"{"id":"2","command":"echo","message":"hello"}"#;
117        let req: RawRequest = serde_json::from_str(json).unwrap();
118        assert_eq!(req.id, "2");
119        assert_eq!(req.command, "echo");
120        // "message" is captured in the flattened params
121        assert_eq!(req.params["message"], "hello");
122    }
123
124    #[test]
125    fn raw_request_preserves_unknown_fields() {
126        let json = r#"{"id":"3","command":"ping","future_field":"abc","nested":{"x":1}}"#;
127        let req: RawRequest = serde_json::from_str(json).unwrap();
128        assert_eq!(req.params["future_field"], "abc");
129        assert_eq!(req.params["nested"]["x"], 1);
130    }
131
132    #[test]
133    fn raw_request_with_lsp_hints() {
134        let json = r#"{"id":"4","command":"ping","lsp_hints":{"completions":["foo","bar"]}}"#;
135        let req: RawRequest = serde_json::from_str(json).unwrap();
136        assert!(req.lsp_hints.is_some());
137        let hints = req.lsp_hints.unwrap();
138        assert_eq!(hints["completions"][0], "foo");
139    }
140
141    #[test]
142    fn response_success_round_trip() {
143        let resp = Response::success("42", serde_json::json!({"command": "pong"}));
144        let json_str = serde_json::to_string(&resp).unwrap();
145        let v: serde_json::Value = serde_json::from_str(&json_str).unwrap();
146        assert_eq!(v["id"], "42");
147        assert_eq!(v["success"], true);
148        assert_eq!(v["command"], "pong");
149    }
150
151    #[test]
152    fn response_error_round_trip() {
153        let resp = Response::error("99", "unknown_command", "unknown command: foo");
154        let json_str = serde_json::to_string(&resp).unwrap();
155        let v: serde_json::Value = serde_json::from_str(&json_str).unwrap();
156        assert_eq!(v["id"], "99");
157        assert_eq!(v["success"], false);
158        assert_eq!(v["code"], "unknown_command");
159        assert_eq!(v["message"], "unknown command: foo");
160    }
161
162    // --- Error formatting ---
163
164    #[test]
165    fn error_display_symbol_not_found() {
166        let err = AftError::SymbolNotFound {
167            name: "foo".into(),
168            file: "bar.rs".into(),
169        };
170        assert_eq!(err.to_string(), "symbol 'foo' not found in bar.rs");
171        assert_eq!(err.code(), "symbol_not_found");
172    }
173
174    #[test]
175    fn error_display_ambiguous_symbol() {
176        let err = AftError::AmbiguousSymbol {
177            name: "Foo".into(),
178            candidates: vec!["a.rs:10".into(), "b.rs:20".into()],
179        };
180        let s = err.to_string();
181        assert!(s.contains("Foo"));
182        assert!(s.contains("a.rs:10, b.rs:20"));
183    }
184
185    #[test]
186    fn error_display_parse_error() {
187        let err = AftError::ParseError {
188            message: "unexpected token".into(),
189        };
190        assert_eq!(err.to_string(), "parse error: unexpected token");
191    }
192
193    #[test]
194    fn error_display_file_not_found() {
195        let err = AftError::FileNotFound {
196            path: "/tmp/missing.rs".into(),
197        };
198        assert_eq!(err.to_string(), "file not found: /tmp/missing.rs");
199    }
200
201    #[test]
202    fn error_display_invalid_request() {
203        let err = AftError::InvalidRequest {
204            message: "missing field".into(),
205        };
206        assert_eq!(err.to_string(), "invalid request: missing field");
207    }
208
209    #[test]
210    fn error_display_checkpoint_not_found() {
211        let err = AftError::CheckpointNotFound {
212            name: "pre-refactor".into(),
213        };
214        assert_eq!(err.to_string(), "checkpoint not found: pre-refactor");
215        assert_eq!(err.code(), "checkpoint_not_found");
216    }
217
218    #[test]
219    fn error_display_no_undo_history() {
220        let err = AftError::NoUndoHistory {
221            path: "src/main.rs".into(),
222        };
223        assert_eq!(err.to_string(), "no undo history for: src/main.rs");
224        assert_eq!(err.code(), "no_undo_history");
225    }
226
227    #[test]
228    fn error_display_ambiguous_match() {
229        let err = AftError::AmbiguousMatch {
230            pattern: "TODO".into(),
231            count: 5,
232        };
233        assert_eq!(
234            err.to_string(),
235            "pattern 'TODO' matches 5 occurrences, expected exactly 1"
236        );
237        assert_eq!(err.code(), "ambiguous_match");
238    }
239
240    #[test]
241    fn error_display_project_too_large() {
242        let err = AftError::ProjectTooLarge {
243            count: 20001,
244            max: 20000,
245        };
246        assert_eq!(
247            err.to_string(),
248            "project has 20001 source files, exceeding max_callgraph_files=20000. Call-graph operations (callers, trace_to, trace_to_symbol, trace_data, impact) are disabled for this root. Open a specific subdirectory or raise max_callgraph_files in config."
249        );
250        assert_eq!(err.code(), "project_too_large");
251    }
252
253    #[test]
254    fn error_to_json_has_code_and_message() {
255        let err = AftError::FileNotFound { path: "/x".into() };
256        let j = err.to_error_json();
257        assert_eq!(j["code"], "file_not_found");
258        assert!(j["message"].as_str().unwrap().contains("/x"));
259    }
260
261    // --- Config defaults ---
262
263    #[test]
264    fn config_default_values() {
265        let cfg = Config::default();
266        assert!(cfg.project_root.is_none());
267        assert_eq!(cfg.validation_depth, 1);
268        assert_eq!(cfg.checkpoint_ttl_hours, 24);
269        assert_eq!(cfg.max_symbol_depth, 10);
270        assert_eq!(cfg.formatter_timeout_secs, 10);
271        assert_eq!(cfg.type_checker_timeout_secs, 30);
272        assert_eq!(cfg.max_callgraph_files, 5_000);
273    }
274}
aft/lib.rs

aft/
lib.rs
