feat(engine): Julia language extractor (.jl files)

Adds tree-sitter-julia grammar (tree-sitter/tree-sitter-julia v0.25.0)
wired through the standard LanguageExtractor pattern. Extracts function
definitions (both 'function ... end' and short 'f() = ...' forms),
call edges, and 'using'/'import' statements.

Key AST quirk: Julia's grammar uses no named fields — the extractor uses
a visitNode hook throughout. Short-form functions are assignment nodes
with a call_expression LHS, not a dedicated node type. const_statement
wraps an inner assignment. 10 new tests all pass.

Author: Broccolito

engine/PATCHES.md

@@ -23,3 +23,16 @@ Perl — each documented as a numbered entry below when it lands.
   to intercept `binary_operator` nodes: rhs=`function_definition` → function
   node; plain rhs → variable node. No class support (S3/S4/R5/R6 are runtime
   constructs). `library()`/`require()` are extracted as plain function calls.
+
+### Julia (added 2026-05-30)
+- WASM grammar: `engine/src/extraction/wasm/tree-sitter-julia.wasm` from tree-sitter/tree-sitter-julia v0.25.0
+- Extension map: `.jl` → `julia`
+- Extractor: `engine/src/extraction/languages/julia.ts`
+- Tests: added `Julia Extraction` describe block in `engine/__tests__/extraction.test.ts`
+- Notes: Julia's tree-sitter grammar uses **no named fields** (all `childForFieldName` calls
+  return null). The extractor uses `visitNode` throughout. Key AST quirks:
+  - `function_definition`: children by index — `[0]=function`, `[1]=signature(call_expression(identifier, argument_list))`, `[2]=block`, `[3]=end`
+  - Short-form functions `f() = expr` are parsed as `assignment` with a `call_expression` on the LHS (not a dedicated `short_function_definition` node)
+  - `const_statement` wraps an inner `assignment` node
+  - `macro_definition` has the same structure as `function_definition`
+  - Call edges work via the standard `call_expression` in `callTypes`; `visitFunctionBody` recursively finds them

engine/__tests__/extraction.test.ts

@@ -4434,3 +4434,140 @@ lapply(1:10, function(x) x * 2)
     expect(functions).toHaveLength(0);
   });
 });
+
+describe('Julia Extraction', () => {
+  it('should detect Julia files', () => {
+    expect(detectLanguage('analysis.jl')).toBe('julia');
+    expect(detectLanguage('src/utils.jl')).toBe('julia');
+  });
+
+  it('should report Julia as supported', () => {
+    expect(isLanguageSupported('julia')).toBe(true);
+    expect(getSupportedLanguages()).toContain('julia');
+  });
+
+  it('should create a file node for Julia files', () => {
+    const code = `
+function hello(name)
+    "Hello, \${name}"
+end
+`;
+    const result = extractFromSource('hello.jl', code);
+
+    const fileNode = result.nodes.find((n) => n.kind === 'file');
+    expect(fileNode).toBeDefined();
+    expect(fileNode?.name).toBe('hello.jl');
+    expect(fileNode?.language).toBe('julia');
+  });
+
+  it('should extract long-form function definitions (function ... end)', () => {
+    const code = `
+function hello(name)
+    "Hello, \${name}"
+end
+
+function greet()
+    hello("world")
+end
+
+function main()
+    println(greet())
+end
+`;
+    const result = extractFromSource('funcs.jl', code);
+
+    const functions = result.nodes.filter((n) => n.kind === 'function');
+    const names = functions.map((f) => f.name).sort();
+    expect(names).toContain('hello');
+    expect(names).toContain('greet');
+    expect(names).toContain('main');
+  });
+
+  it('should extract short-form function definitions (f() = ...)', () => {
+    const code = `
+greet() = hello("world")
+add(a, b) = a + b
+`;
+    const result = extractFromSource('short.jl', code);
+
+    const functions = result.nodes.filter((n) => n.kind === 'function');
+    const names = functions.map((f) => f.name).sort();
+    expect(names).toContain('greet');
+    expect(names).toContain('add');
+  });
+
+  it('should extract call edges from function bodies', () => {
+    const code = `
+function hello(name)
+    "Hello, \${name}"
+end
+
+greet() = hello("world")
+
+function main()
+    println(greet())
+end
+`;
+    const result = extractFromSource('calls.jl', code);
+
+    const calls = result.unresolvedReferences.filter((r) => r.referenceKind === 'calls');
+    const callNames = calls.map((c) => c.referenceName);
+
+    // greet calls hello; main calls println and greet
+    expect(callNames).toContain('hello');
+    expect(callNames).toContain('greet');
+    expect(callNames).toContain('println');
+  });
+
+  it('should extract using statements as imports', () => {
+    const code = `
+using Pkg
+using Statistics: mean, std
+`;
+    const result = extractFromSource('imports.jl', code);
+
+    const imports = result.nodes.filter((n) => n.kind === 'import');
+    const names = imports.map((i) => i.name);
+    expect(names).toContain('Pkg');
+    expect(names).toContain('Statistics');
+  });
+
+  it('should extract import statements', () => {
+    const code = `
+import Statistics
+import Base: show, print
+`;
+    const result = extractFromSource('imports2.jl', code);
+
+    const imports = result.nodes.filter((n) => n.kind === 'import');
+    const names = imports.map((i) => i.name);
+    expect(names).toContain('Statistics');
+    expect(names).toContain('Base');
+  });
+
+  it('should extract plain variable assignments', () => {
+    const code = `
+x = 42
+name = "Alice"
+`;
+    const result = extractFromSource('vars.jl', code);
+
+    const variables = result.nodes.filter((n) => n.kind === 'variable');
+    const names = variables.map((v) => v.name);
+    expect(names).toContain('x');
+    expect(names).toContain('name');
+  });
+
+  it('should extract const declarations as constants', () => {
+    const code = `
+const PI_VAL = 3.14159
+const MAX_SIZE = 1000
+`;
+    const result = extractFromSource('consts.jl', code);
+
+    const constants = result.nodes.filter((n) => n.kind === 'constant');
+    const names = constants.map((c) => c.name);
+    expect(names).toContain('PI_VAL');
+    expect(names).toContain('MAX_SIZE');
+  });
+});

engine/src/extraction/grammars.ts

@@ -39,6 +39,7 @@ const WASM_GRAMMAR_FILES: Record<GrammarLanguage, string> = {
   luau: 'tree-sitter-luau.wasm',
   objc: 'tree-sitter-objc.wasm',
   r: 'tree-sitter-r.wasm',
+  julia: 'tree-sitter-julia.wasm',
 };
 
 /**
@@ -98,6 +99,7 @@ export const EXTENSION_MAP: Record<string, Language> = {
   '.mm': 'objc',
   '.R': 'r',
   '.r': 'r',
+  '.jl': 'julia',
   // XML: file-level tracking; the MyBatis extractor matches `<mapper namespace="...">`
   // shape and emits SQL-statement nodes (other XML returns empty).
   '.xml': 'xml',
@@ -182,7 +184,7 @@ export async function loadGrammarsForLanguages(languages: Language[]): Promise<v
       // ABI-13 build that corrupts the shared WASM heap under web-tree-sitter
       // 0.25 (drops nested calls/imports on every file after the first); we
       // vendor the upstream ABI-15 wasm instead.
-      const wasmPath = (lang === 'pascal' || lang === 'scala' || lang === 'lua' || lang === 'luau' || lang === 'r')
+      const wasmPath = (lang === 'pascal' || lang === 'scala' || lang === 'lua' || lang === 'luau' || lang === 'r' || lang === 'julia')
         ? path.join(__dirname, 'wasm', wasmFile)
         : require.resolve(`tree-sitter-wasms/out/${wasmFile}`);
       const language = await WasmLanguage.load(wasmPath);
@@ -369,6 +371,7 @@ export function getLanguageDisplayName(language: Language): string {
     luau: 'Luau',
     objc: 'Objective-C',
     r: 'R',
+    julia: 'Julia',
     yaml: 'YAML',
     twig: 'Twig',
     xml: 'XML',

engine/src/extraction/languages/index.ts

@@ -27,6 +27,7 @@ import { luaExtractor } from './lua';
 import { luauExtractor } from './luau';
 import { objcExtractor } from './objc';
 import { rExtractor } from './r';
+import { juliaExtractor } from './julia';
 
 export const EXTRACTORS: Partial<Record<Language, LanguageExtractor>> = {
   typescript: typescriptExtractor,
@@ -51,4 +52,5 @@ export const EXTRACTORS: Partial<Record<Language, LanguageExtractor>> = {
   luau: luauExtractor,
   objc: objcExtractor,
   r: rExtractor,
+  julia: juliaExtractor,
 };