added typescript support with regression tracking

Author: rohitkg98

.github/workflows/ci.yml

@@ -0,0 +1,34 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    name: Tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache cargo
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Unit tests
+        run: cargo test
+
+      - name: Regression tests
+        run: |
+          cargo build --quiet
+          SMARTGREP="./target/debug/smartgrep" bash tests/regression/run.sh

AGENTS_README.md

@@ -10,7 +10,7 @@ You have access to `smartgrep`, a structural code navigation tool. Read this bef
 
 It is **not a text search tool**. It is a **structural search tool**. It understands code, not bytes.
 
-**Supported languages: Rust, Java, Go.** smartgrep only indexes `.rs`, `.go`, and `.java` files. It has no knowledge of `.md`, `.yaml`, `.toml`, `.json`, `.py`, `.ts`, or any other file type. For those, handle them as you normally would without smartgrep — using smartgrep for code does not mean ignoring everything else.
+**Supported languages: Rust, Java, Go, and TypeScript.** smartgrep only indexes `.rs`, `.go`, `.java`, `.ts`, and `.tsx` files. It has no knowledge of `.md`, `.yaml`, `.toml`, `.json`, `.py`, or any other file type. For those, handle them as you normally would without smartgrep — using smartgrep for code does not mean ignoring everything else.
 
 ---
 
@@ -69,14 +69,19 @@ Symbols use language-native kind strings, not a shared enum. The `kind` field on
 | **Rust** | fn, method, struct, enum, trait, impl, const, type, mod |
 | **Java** | class, interface, enum, method, record |
 | **Go** | func, method, struct, interface, const, type |
+| **TypeScript** | function, class, interface, enum, type, method, const, namespace |
 
 **Dependency kinds:** Call, TypeRef, Implements (renamed from FunctionCall, TypeReference, TraitImpl)
 
 **`interfaces` vs `traits`:**
-- `interfaces` = kind="interface" (Java and Go only)
+- `interfaces` = kind="interface" (Java, Go, and TypeScript)
 - `traits` = kind="trait" (Rust only)
 - These are distinct source keywords — they do not alias each other
 
+**Cross-language queries:**
+- `functions` → finds Rust fn, Go func, TS function (all function-like symbols)
+- `fns` → Rust only, `funcs` → Go only, `function` → TS only
+
 ## Query DSL
 
 ### Grammar
@@ -88,6 +93,7 @@ source      = source_kind [implementing_clause] [in_clause] [where_clause]
 source_kind = "symbols" | "structs" | "functions" | "methods" | "traits"
             | "enums" | "impls" | "consts" | "types" | "modules"
             | "classes" | "interfaces" | "records"
+            | "functions" | "namespaces"
             | "symbol" <name> | "deps" [<name>] | "refs" [<name>]
 implementing_clause = "implementing" <name>
 in_clause   = "in" '<path_substring>'
@@ -216,7 +222,7 @@ smartgrep map --format json | jq '.[].dir'
 
 ### Pattern 7 — Cross-language queries
 
-Same DSL works across Rust, Java, and Go. Use language-native kinds:
+Same DSL works across Rust, Java, Go, and TypeScript. Use language-native kinds:
 
 ```bash
 # Go: methods on a specific receiver type
@@ -239,6 +245,15 @@ smartgrep query "traits where visibility = public | with deps | show name, file,
 
 # Rust: structs implementing a trait
 smartgrep query "structs implementing Display"
+
+# TypeScript: find decorated classes
+smartgrep query "classes where attributes contains '@Injectable' | with fields"
+
+# TypeScript: interfaces in a specific directory
+smartgrep query "interfaces where file contains 'src/types/' | with fields"
+
+# TypeScript: namespaces
+smartgrep query "namespaces | with fields"
 ```
 
 ---

CLAUDE.md

@@ -31,14 +31,14 @@ Parser (tree-sitter) → IR → Index Builder → Index → Command
 
 ## Key design decisions
 - IR exists so we can add languages by writing one parser, without changing the index builder or commands
-- Parsers are tested against fixture files — small .rs/.java files in tests/fixtures/
+- Parsers are tested against fixture files — small .rs/.java/.go/.ts files in tests/fixtures/
 - Index builder is tested with hand-built IR — no parsing needed
 - Commands are tested with hand-built Index — no builder needed
 - Auto-indexing: queries trigger indexing implicitly. Re-indexes when source files change.
 
 ## File layout
 - `src/ir/` — IR types and validation
-- `src/parser/` — tree-sitter parsers (rust.rs, later java.rs)
+- `src/parser/` — tree-sitter parsers (rust.rs, java.rs, go.rs, typescript.rs); `mod.rs` has `parse_by_extension` dispatch
 - `src/index/` — index types, builder, storage, auto-detection
 - `src/commands/` — CLI commands (context, ls, show, deps, refs)
 - `src/format/` — text table and JSON output
@@ -52,9 +52,16 @@ Symbols use language-native kind strings, not a shared enum:
 - **Rust:** fn, method, struct, enum, trait, impl, const, type, mod
 - **Java:** class, interface, enum, method, record
 - **Go:** func, method, struct, interface, const, type
+- **TypeScript:** function, class, interface, enum, type, method, const, namespace
 
 Dependency kinds: Call (was FunctionCall), TypeRef (was TypeReference), Implements (was TraitImpl)
 
+### Cross-language queries
+Umbrella terms find symbols across all languages:
+- `functions` → finds Rust `fn`, Go `func`, TS `function`
+- `fns` → Rust only, `funcs` → Go only, `function` → TS only
+Language-specific terms target one language. Shared terms like `structs`, `interfaces`, `enums` work as before.
+
 ### Prefer smartgrep query for compound questions
 ```bash
 # Instead of multiple grep/read calls, compose one query:
@@ -93,12 +100,15 @@ smartgrep query "functions where name starts_with 'New' and file contains 'servi
 ```
 
 ### Language notes
-- **Go/Java interfaces** → use `interfaces` (kind="interface")
+- **Go/Java/TS interfaces** → use `interfaces` (kind="interface")
 - **Rust traits** → use `traits` (kind="trait", Rust only)
-- **`interfaces` and `traits` are distinct** — `interfaces` matches Java/Go interface, `traits` matches Rust trait
+- **`interfaces` and `traits` are distinct** — `interfaces` matches Java/Go/TS interface, `traits` matches Rust trait
 - **Go method receivers** → stored in `parent` field (e.g., `methods where parent = MultiGateway`)
 - **Generated code** → filter out with `where file not contains '.pb.go'`
 - **`implementing` clause** → `structs implementing Display` finds types that implement a trait/interface
+- **TS decorators** → stored in `attributes` (e.g., `classes where attributes contains '@Injectable'`)
+- **TS namespaces** → `namespaces` or `namespace` (kind="namespace", TS only)
+- **node_modules** → automatically skipped during indexing
 
 ### When to use smartgrep vs file reading
 - **Use smartgrep**: finding symbols, understanding structure, exploring dependencies, listing functions/structs

Cargo.lock

@@ -18,6 +18,7 @@ tree-sitter = "0.24"
 tree-sitter-rust = "0.23"
 tree-sitter-java = "0.23"
 tree-sitter-go = "0.23"
+tree-sitter-typescript = "0.23"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 walkdir = "2"

Cargo.toml

@@ -6,24 +6,24 @@ Full agent reference: `AGENTS_README.md` in this repo (if available) or see inli
 
 ## Supported languages
 
-smartgrep parses **Rust, Java, and Go** only. It has no knowledge of other file types.
+smartgrep parses **Rust, Java, Go, and TypeScript** only. It has no knowledge of other file types.
 
-**Use smartgrep for:** `.rs`, `.go`, `.java` files — structural questions about code.
+**Use smartgrep for:** `.rs`, `.go`, `.java`, `.ts`, `.tsx` files — structural questions about code.
 
-**For everything else** (`.md`, `.yaml`, `.toml`, `.json`, `.py`, `.ts`, `.js`, Dockerfiles, config files, documentation) — handle as you normally would without smartgrep. It has no knowledge of these file types.
+**For everything else** (`.md`, `.yaml`, `.toml`, `.json`, `.py`, `.js`, Dockerfiles, config files, documentation) — handle as you normally would without smartgrep. It has no knowledge of these file types.
 
 Using smartgrep for code does not mean ignoring non-code files. Documentation and config often contain context the code index cannot surface.
 
 ## When to use smartgrep
 
 Use it when the user asks about:
-- Code structure, architecture, or organization in Rust, Java, or Go files
-- Finding classes, functions, interfaces, enums, records, structs, traits
+- Code structure, architecture, or organization in Rust, Java, Go, or TypeScript files
+- Finding classes, functions, interfaces, enums, records, structs, traits, namespaces
 - Dependencies between symbols or what references a symbol
-- Exploring an unfamiliar Rust/Java/Go codebase
+- Exploring an unfamiliar Rust/Java/Go/TypeScript codebase
 - Finding implementations of an interface or trait
 - Listing endpoints, services, controllers, consumers
-- Any structural question that would otherwise need multiple grep/read calls across `.rs`, `.go`, or `.java` files
+- Any structural question that would otherwise need multiple grep/read calls across `.rs`, `.go`, `.java`, `.ts`, or `.tsx` files
 
 ## Detecting availability
 
@@ -99,16 +99,21 @@ Symbols use language-native kind strings (not a shared enum):
 | **Rust** | fn, method, struct, enum, trait, impl, const, type, mod |
 | **Java** | class, interface, enum, method, record |
 | **Go** | func, method, struct, interface, const, type |
+| **TypeScript** | function, class, interface, enum, type, method, const, namespace |
 
 **Dependency kinds:** Call, TypeRef, Implements
 
-**`interfaces` vs `traits`:** `interfaces` = Java/Go interface; `traits` = Rust trait. They are distinct.
+**`interfaces` vs `traits`:** `interfaces` = Java/Go/TS interface; `traits` = Rust trait. They are distinct.
+
+**Cross-language queries:**
+- `functions` → finds Rust fn, Go func, TS function (all function-like symbols)
+- `fns` → Rust only, `funcs` → Go only, `function` → TS only
 
 ## Query DSL
 
 ### Sources
-- `structs`, `functions`, `methods`, `traits`, `enums`, `symbols` — list by kind
-- `interfaces` — Java/Go interfaces (not Rust traits)
+- `structs`, `functions`, `methods`, `traits`, `enums`, `symbols`, `namespaces` — list by kind
+- `interfaces` — Java/Go/TS interfaces (not Rust traits)
 - `traits` — Rust traits only
 - `symbol <name>` — single symbol lookup
 - `deps [name]` — dependencies (optionally for a symbol)
@@ -153,6 +158,18 @@ Semicolon-separated: `"structs | limit 5 ; functions | limit 5"`
 | List services | `smartgrep query "structs where attributes contains '@Service' \| show name, file"` |
 | Public API in a directory | `smartgrep query "functions where file contains 'src/api' and visibility = public \| show name, file, signature"` |
 
+### TypeScript examples
+```bash
+# TypeScript: find decorated classes
+smartgrep query "classes where attributes contains '@Injectable' | with fields"
+
+# TypeScript: interfaces in a specific directory
+smartgrep query "interfaces where file contains 'src/types/' | with fields"
+
+# TypeScript: all exported functions (cross-language)
+smartgrep query "functions where visibility = public and file contains 'src/'"
+```
+
 ## Large-repo warnings
 
 **Never run bare `smartgrep map` or `smartgrep ls functions` on a repo with 100+ files.** The output can be hundreds of lines and burns context budget without adding value. Always scope first:
@@ -170,6 +187,8 @@ smartgrep query "functions where file contains 'src/api/' | show name, file | li
 
 **Generated files are excluded by default.** Bindgen output, protobuf stubs, and vendor code are filtered out automatically. Use `--include-generated` only when you specifically need to inspect generated code.
 
+**node_modules** is automatically skipped during indexing.
+
 ## Output guidance
 
 Present results concisely. Summarize patterns ("5 controllers, all in src/api/"). Quote symbol names and file paths precisely. Use smartgrep output directly rather than re-reading files unless the user needs full implementation bodies.

SKILL.md

@@ -5,9 +5,6 @@ use anyhow::Result;
 use crate::daemon::client;
 use crate::format::OutputFormat;
 use crate::index::auto;
-use crate::parser::go as go_parser;
-use crate::parser::java as java_parser;
-use crate::parser::rust as rust_parser;
 
 /// Run the `context` command: parse a single file and print its symbols.
 pub fn run(file: &Path, format_str: &str, use_daemon: bool) -> Result<()> {
@@ -28,16 +25,7 @@ pub fn run(file: &Path, format_str: &str, use_daemon: bool) -> Result<()> {
     let source = std::fs::read_to_string(file)
         .map_err(|e| anyhow::anyhow!("Cannot read {}: {}", file.display(), e))?;
 
-    let ext = file.extension().and_then(|e| e.to_str()).unwrap_or("");
-    let ir = match ext {
-        "go" => go_parser::parse_file(file, &source)?,
-        "java" => java_parser::parse_file(file, &source)?,
-        "rs" => rust_parser::parse_file(file, &source)?,
-        _ => return Err(anyhow::anyhow!(
-            "Unsupported file type '.{}'. smartgrep supports .rs, .java, and .go files.",
-            ext
-        )),
-    };
+    let ir = crate::parser::parse_by_extension(file, &source)?;
 
     let output = match format_str.parse::<OutputFormat>().unwrap() {
         OutputFormat::Json => crate::format::json::format_symbols(&ir),

src/commands/context.rs

@@ -27,8 +27,9 @@ pub fn run(symbol_type: &Option<String>, in_path: &Option<String>, format_str: &
 
     let kind_filter = symbol_type.as_deref().and_then(normalize_kind_filter);
 
-    let mut symbols: Vec<_> = if let Some(ref kind) = kind_filter {
-        index.by_kind(kind)
+    let mut symbols: Vec<_> = if let Some(ref kinds) = kind_filter {
+        let kind_refs: Vec<&str> = kinds.iter().map(|s| s.as_str()).collect();
+        index.by_kinds(&kind_refs)
     } else {
         index.symbols.iter().collect()
     };

src/commands/ls.rs

@@ -172,14 +172,14 @@ fn group_by_dir(
 
 fn symbol_sort_order(kind: &str) -> u8 {
     match kind {
-        "struct" | "class" | "record" | "enum" | "trait" | "interface" | "type" | "const" => 0,
+        "struct" | "class" | "record" | "enum" | "trait" | "interface" | "type" | "const" | "namespace" => 0,
         _ => 1,
     }
 }
 
 fn inline_name(s: &Symbol) -> String {
     match s.kind.as_str() {
-        "fn" | "func" => s.name.clone(),
+        "fn" | "func" | "function" => s.name.clone(),
         "struct" => format!("struct {}", s.name),
         "class" => format!("class {}", s.name),
         "record" => format!("record {}", s.name),
@@ -189,6 +189,7 @@ fn inline_name(s: &Symbol) -> String {
         "type" => format!("type {}", s.name),
         "const" => format!("const {}", s.name),
         "mod" => format!("mod {}", s.name),
+        "namespace" => format!("namespace {}", s.name),
         _ => s.name.clone(),
     }
 }
@@ -201,7 +202,8 @@ fn kind_label(kind: &str) -> Option<(&'static str, u8)> {
         "type" => Some(("type", 3)),
         "const" => Some(("const", 4)),
         "mod" => Some(("mod", 5)),
-        "fn" | "func" => Some(("fn", 6)),
+        "fn" | "func" | "function" => Some(("fn", 6)),
+        "namespace" => Some(("ns", 7)),
         _ => None,
     }
 }

src/commands/map.rs

@@ -95,7 +95,7 @@ fn format_symbol_detail(sym: &Symbol, alias: Option<&path_alias::PathAlias>) ->
     }
 
     // Params (for functions/methods)
-    if (sym.kind == "fn" || sym.kind == "func" || sym.kind == "method") && !sym.params.is_empty() {
+    if (sym.kind == "fn" || sym.kind == "func" || sym.kind == "function" || sym.kind == "method") && !sym.params.is_empty() {
         let param_strs: Vec<String> = sym
             .params
             .iter()