Fix CLI indexer bugs and build warnings

- Fix glob pattern matching by using relative paths for pattern comparison
- Fix vars file naming (.acp.vars.json instead of .acp.cache.vars.json)
- Enhance parser to extract @acp: annotations and build symbols
- Fix config resolution when indexing subdirectories
- Remove unused cfg attribute and prefix unused variables with underscore

Author: ddunnock

cli/src/config/mod.rs

@@ -189,8 +189,7 @@ fn default_workers() -> usize {
     num_cpus::get().max(1)
 }
 
-// Fallback if num_cpus not available
-#[cfg(not(feature = "num_cpus"))]
+// Fallback mock for num_cpus
 mod num_cpus {
     pub fn get() -> usize {
         4

cli/src/index/indexer.rs

@@ -112,13 +112,30 @@ impl Indexer {
             .into_iter()
             .filter_map(|e| e.ok())
             .filter(|e| e.file_type().is_file())
-            .map(|e| e.path().to_string_lossy().to_string())
-            .filter(|path| {
+            .filter_map(|e| {
+                // Get path relative to root for pattern matching
+                let full_path = e.path().to_string_lossy().to_string();
+                let relative_path = e.path()
+                    .strip_prefix(root)
+                    .map(|p| p.to_string_lossy().to_string())
+                    .unwrap_or_else(|_| full_path.clone());
+
                 // Must match at least one include pattern
-                let included = include_patterns.iter().any(|p| p.matches(path));
+                let match_opts = glob::MatchOptions {
+                    case_sensitive: true,
+                    require_literal_separator: false,
+                    require_literal_leading_dot: false,
+                };
+                let included = include_patterns.is_empty() ||
+                    include_patterns.iter().any(|p| p.matches_with(&relative_path, match_opts));
                 // Must not match any exclude pattern
-                let excluded = exclude_patterns.iter().any(|p| p.matches(path));
-                included && !excluded
+                let excluded = exclude_patterns.iter().any(|p| p.matches_with(&relative_path, match_opts));
+
+                if included && !excluded {
+                    Some(full_path)
+                } else {
+                    None
+                }
             })
             .collect();
 

cli/src/main.rs

@@ -273,7 +273,24 @@ async fn main() -> anyhow::Result<()> {
     match cli.command {
         Commands::Index { root, output, vars } => {
             println!("{} Indexing codebase...", style("→").cyan());
-            
+
+            // Use config from target root if it exists, otherwise use defaults
+            // This avoids pattern mismatches when indexing a subdirectory
+            let config = {
+                let root_config = root.join(".acp.config.json");
+                let root_str = root.to_string_lossy();
+                if root_config.exists() {
+                    // Config in target directory takes precedence
+                    Config::load(&root_config).unwrap_or_default()
+                } else if root_str != "." && root_str != "./" {
+                    // Indexing a subdirectory - use defaults to avoid pattern mismatches
+                    // (parent's "src/**/*" won't match files when root IS src/)
+                    Config::default()
+                } else {
+                    config
+                }
+            };
+
             let indexer = Indexer::new(config)?;
             let cache = indexer.index(&root).await?;
 
@@ -285,7 +302,13 @@ async fn main() -> anyhow::Result<()> {
 
             if vars {
                 let vars_file = indexer.generate_vars(&cache);
-                let vars_path = output.with_extension("vars.json");
+                // Replace .cache.json with .vars.json (or append .vars.json if different pattern)
+                let output_str = output.to_string_lossy();
+                let vars_path = if output_str.contains(".cache.json") {
+                    PathBuf::from(output_str.replace(".cache.json", ".vars.json"))
+                } else {
+                    output.with_extension("vars.json")
+                };
                 vars_file.write_json(&vars_path)?;
                 println!("{} Vars written to {}", style("✓").green(), vars_path.display());
             }

cli/src/parse/mod.rs

@@ -61,39 +61,123 @@ impl Parser {
     pub fn parse<P: AsRef<Path>>(&self, path: P) -> Result<ParseResult> {
         let path = path.as_ref();
         let content = std::fs::read_to_string(path)?;
-        let lang = Language::from_path(path)
+        let _lang = Language::from_path(path)
             .ok_or_else(|| AcpError::UnsupportedLanguage(
                 path.extension()
                     .map(|e| e.to_string_lossy().to_string())
                     .unwrap_or_default()
             ))?;
 
-        // TODO: Implement actual tree-sitter parsing
-        // For now, return a basic result with file metadata
         let lines = content.lines().count();
         let file_name = path.file_stem()
             .map(|s| s.to_string_lossy().to_string())
             .unwrap_or_default();
+        let file_path = path.to_string_lossy().to_string();
+
+        // Parse @acp: annotations from source
+        let annotations = self.parse_annotations(&content);
+
+        // Extract file-level metadata from annotations
+        let mut module_name = file_name.clone();
+        let mut domains = vec![];
+        let mut layer = None;
+        let mut symbols = vec![];
+        let mut symbol_names = vec![];
+        let mut calls = vec![];
+
+        // Track current symbol context for multi-line annotations
+        let mut current_symbol: Option<SymbolBuilder> = None;
+
+        for ann in &annotations {
+            match ann.name.as_str() {
+                "module" => {
+                    if let Some(val) = &ann.value {
+                        module_name = val.trim_matches('"').to_string();
+                    }
+                }
+                "domain" => {
+                    if let Some(val) = &ann.value {
+                        domains.push(val.trim_matches('"').to_string());
+                    }
+                }
+                "layer" => {
+                    if let Some(val) = &ann.value {
+                        layer = Some(val.trim_matches('"').to_string());
+                    }
+                }
+                "symbol" => {
+                    // Save previous symbol if exists
+                    if let Some(builder) = current_symbol.take() {
+                        let sym = builder.build(&file_path);
+                        symbol_names.push(sym.name.clone());
+                        symbols.push(sym);
+                    }
+                    // Start new symbol
+                    if let Some(val) = &ann.value {
+                        current_symbol = Some(SymbolBuilder::new(
+                            val.trim_matches('"').to_string(),
+                            ann.line,
+                        ));
+                    }
+                }
+                "summary" => {
+                    if let Some(ref mut builder) = current_symbol {
+                        if let Some(val) = &ann.value {
+                            builder.summary = Some(val.trim_matches('"').to_string());
+                        }
+                    }
+                }
+                "calls" => {
+                    if let Some(ref mut builder) = current_symbol {
+                        if let Some(val) = &ann.value {
+                            let callees: Vec<String> = val
+                                .split(',')
+                                .map(|s| s.trim().trim_matches('"').to_string())
+                                .collect();
+                            builder.calls.extend(callees);
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        // Save last symbol
+        if let Some(builder) = current_symbol {
+            let sym = builder.build(&file_path);
+            if !sym.calls.is_empty() {
+                calls.push((sym.name.clone(), sym.calls.clone()));
+            }
+            symbol_names.push(sym.name.clone());
+            symbols.push(sym);
+        }
+
+        // Build call edges for earlier symbols
+        for sym in &symbols {
+            if !sym.calls.is_empty() {
+                calls.push((sym.name.clone(), sym.calls.clone()));
+            }
+        }
 
         let file = FileEntry {
-            path: path.to_string_lossy().to_string(),
-            module: file_name.clone(),
+            path: file_path,
+            module: module_name,
             lines,
-            domains: vec![],
-            layer: None,
+            domains,
+            layer,
             stability: Stability::Active,
             depends: vec![],
-            exports: vec![],
-            symbols: vec![],
+            exports: symbol_names.clone(),
+            symbols: symbol_names,
             keywords: vec![],
             hash: Some(format!("{:x}", md5::compute(&content))),
             guardrails: None,
         };
 
         Ok(ParseResult {
             file,
-            symbols: vec![],
-            calls: vec![],
+            symbols,
+            calls,
         })
     }
 
@@ -128,4 +212,42 @@ pub struct Annotation {
     pub name: String,
     pub value: Option<String>,
     pub line: usize,
+}
+
+/// Helper to build SymbolEntry from annotations
+struct SymbolBuilder {
+    name: String,
+    line: usize,
+    summary: Option<String>,
+    calls: Vec<String>,
+}
+
+impl SymbolBuilder {
+    fn new(name: String, line: usize) -> Self {
+        Self {
+            name,
+            line,
+            summary: None,
+            calls: vec![],
+        }
+    }
+
+    fn build(self, file_path: &str) -> SymbolEntry {
+        SymbolEntry {
+            name: self.name,
+            fqn: None,
+            symbol_type: SymbolType::Fn,
+            file: file_path.to_string(),
+            lines: [self.line, self.line + 10], // Approximate
+            summary: self.summary,
+            signature: None,
+            exported: true,
+            async_fn: false,
+            calls: self.calls,
+            throws: vec![],
+            flags: vec![],
+            side_effects: vec![],
+            complexity: None,
+        }
+    }
 }

cli/src/watch.rs

@@ -15,12 +15,12 @@ use crate::error::Result;
 
 /// File watcher for incremental updates
 pub struct FileWatcher {
-    config: AcpConfig,
+    _config: AcpConfig,
 }
 
 impl FileWatcher {
     pub fn new(config: AcpConfig) -> Self {
-        Self { config }
+        Self { _config: config }
     }
 
     /// Start watching for changes