test: add comprehensive test coverage across multiple packages

- [x] Add 298 tests for Python chunker functionality - [x] Add 213 tests for chunking types and constants - [x] Add 398 tests for TypeScript/JavaScript chunker - [x] Add 954 tests for MCP server handlers and validation - [x] Add 563 tests for pattern detector and analysis - [x] Add 1149 tests for vector client cache and operations - [x] Add 663 tests for SDK processor, circuit breaker, and deduplication - [x] Add 731 tests for session manager lifecycle and concurrency - [x] Add 331 tests for similarity clustering and term extraction
2026-10-17 05:59:36 +00:00 · 2026-01-11 12:25:58 +00:00
parent e2193e449d
commit 5215ee8617
9 changed files with 6268 additions and 217 deletions
@@ -0,0 +1,298 @@
+package python
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/lukaszraczylo/claude-mnemonic/internal/chunking"
+)
+
+// =============================================================================
+// TEST HELPERS
+// =============================================================================
+
+func createTempPythonFile(t *testing.T, content string) string {
+	t.Helper()
+
+	tmpDir := t.TempDir()
+	filePath := filepath.Join(tmpDir, "test.py")
+
+	err := os.WriteFile(filePath, []byte(content), 0600)
+	require.NoError(t, err)
+
+	return filePath
+}
+
+// =============================================================================
+// TESTS FOR Chunker
+// =============================================================================
+
+func TestNewChunker(t *testing.T) {
+	t.Parallel()
+
+	opts := chunking.DefaultChunkOptions()
+	c := NewChunker(opts)
+
+	assert.NotNil(t, c)
+	assert.NotNil(t, c.parser)
+}
+
+func TestChunker_Language(t *testing.T) {
+	t.Parallel()
+
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	assert.Equal(t, chunking.LanguagePython, c.Language())
+}
+
+func TestChunker_SupportedExtensions(t *testing.T) {
+	t.Parallel()
+
+	c := NewChunker(chunking.DefaultChunkOptions())
+	exts := c.SupportedExtensions()
+
+	assert.Contains(t, exts, ".py")
+}
+
+func TestChunker_Chunk_SimpleFunction(t *testing.T) {
+	t.Parallel()
+
+	code := `def greet(name):
+    """Greets a person by name."""
+    return f"Hello, {name}!"
+`
+
+	filePath := createTempPythonFile(t, code)
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	require.NotEmpty(t, chunks)
+
+	// Should find the greet function
+	var foundGreet bool
+	for _, chunk := range chunks {
+		if chunk.Name == "greet" {
+			foundGreet = true
+			assert.Equal(t, chunking.ChunkTypeFunction, chunk.Type)
+			assert.Equal(t, chunking.LanguagePython, chunk.Language)
+			assert.Contains(t, chunk.Content, "def greet")
+		}
+	}
+	assert.True(t, foundGreet, "Should find 'greet' function")
+}
+
+func TestChunker_Chunk_ClassWithMethods(t *testing.T) {
+	t.Parallel()
+
+	code := `class Calculator:
+    """A simple calculator class."""
+
+    def add(self, a, b):
+        """Adds two numbers."""
+        return a + b
+
+    def multiply(self, a, b):
+        """Multiplies two numbers."""
+        return a * b
+`
+
+	filePath := createTempPythonFile(t, code)
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	require.NotEmpty(t, chunks)
+
+	// Should find the Calculator class and its methods
+	var foundClass, foundAdd, foundMultiply bool
+	for _, chunk := range chunks {
+		switch chunk.Name {
+		case "Calculator":
+			foundClass = true
+			assert.Equal(t, chunking.ChunkTypeClass, chunk.Type)
+		case "add":
+			foundAdd = true
+			assert.Equal(t, chunking.ChunkTypeMethod, chunk.Type)
+			assert.Equal(t, "Calculator", chunk.ParentName)
+		case "multiply":
+			foundMultiply = true
+			assert.Equal(t, chunking.ChunkTypeMethod, chunk.Type)
+			assert.Equal(t, "Calculator", chunk.ParentName)
+		}
+	}
+
+	assert.True(t, foundClass, "Should find 'Calculator' class")
+	assert.True(t, foundAdd, "Should find 'add' method")
+	assert.True(t, foundMultiply, "Should find 'multiply' method")
+}
+
+func TestChunker_Chunk_MultipleFunctions(t *testing.T) {
+	t.Parallel()
+
+	code := `def first_function():
+    pass
+
+def second_function(x, y):
+    return x + y
+
+def third_function():
+    """Has a docstring."""
+    return 42
+`
+
+	filePath := createTempPythonFile(t, code)
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+
+	// Should find all three functions
+	functionNames := make(map[string]bool)
+	for _, chunk := range chunks {
+		if chunk.Type == chunking.ChunkTypeFunction {
+			functionNames[chunk.Name] = true
+		}
+	}
+
+	assert.True(t, functionNames["first_function"])
+	assert.True(t, functionNames["second_function"])
+	assert.True(t, functionNames["third_function"])
+}
+
+func TestChunker_Chunk_FileNotFound(t *testing.T) {
+	t.Parallel()
+
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	_, err := c.Chunk(context.Background(), "/nonexistent/path/file.py")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "read file")
+}
+
+func TestChunker_Chunk_EmptyFile(t *testing.T) {
+	t.Parallel()
+
+	filePath := createTempPythonFile(t, "")
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	assert.Empty(t, chunks)
+}
+
+func TestChunker_Chunk_OnlyComments(t *testing.T) {
+	t.Parallel()
+
+	code := `# This is a comment
+# Another comment
+"""
+This is a module docstring
+"""
+`
+
+	filePath := createTempPythonFile(t, code)
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	// Comments and docstrings without code should not produce chunks
+	assert.Empty(t, chunks)
+}
+
+func TestChunker_Chunk_NestedClass(t *testing.T) {
+	t.Parallel()
+
+	code := `class Outer:
+    class Inner:
+        def inner_method(self):
+            pass
+
+    def outer_method(self):
+        pass
+`
+
+	filePath := createTempPythonFile(t, code)
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	require.NotEmpty(t, chunks)
+
+	// Should find the Outer class at minimum
+	var foundOuter bool
+	for _, chunk := range chunks {
+		if chunk.Name == "Outer" {
+			foundOuter = true
+		}
+	}
+	assert.True(t, foundOuter, "Should find 'Outer' class")
+}
+
+func TestChunker_Chunk_Decorators(t *testing.T) {
+	t.Parallel()
+
+	code := `@staticmethod
+def static_func():
+    pass
+
+@classmethod
+def class_func(cls):
+    pass
+
+@property
+def my_property(self):
+    return self._value
+`
+
+	filePath := createTempPythonFile(t, code)
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	require.NotEmpty(t, chunks)
+
+	// Should find decorated functions
+	functionNames := make(map[string]bool)
+	for _, chunk := range chunks {
+		functionNames[chunk.Name] = true
+	}
+
+	assert.True(t, functionNames["static_func"])
+	assert.True(t, functionNames["class_func"])
+	assert.True(t, functionNames["my_property"])
+}
+
+func TestChunker_Chunk_AsyncFunction(t *testing.T) {
+	t.Parallel()
+
+	code := `async def fetch_data(url):
+    """Fetches data from URL asynchronously."""
+    pass
+
+async def process_items(items):
+    for item in items:
+        await process(item)
+`
+
+	filePath := createTempPythonFile(t, code)
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	require.NotEmpty(t, chunks)
+
+	// Should find async functions
+	functionNames := make(map[string]bool)
+	for _, chunk := range chunks {
+		functionNames[chunk.Name] = true
+	}
+
+	assert.True(t, functionNames["fetch_data"])
+	assert.True(t, functionNames["process_items"])
+}
@@ -0,0 +1,213 @@
+package chunking
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// =============================================================================
+// TESTS FOR Chunk METHODS
+// =============================================================================
+
+func TestChunk_Identifier(t *testing.T) {
+	tests := []struct {
+		name     string
+		expected string
+		chunk    Chunk
+	}{
+		// ===== GOOD CASES =====
+		{
+			name: "top-level function",
+			chunk: Chunk{
+				Name:       "MyFunction",
+				ParentName: "",
+			},
+			expected: "MyFunction",
+		},
+		{
+			name: "method with parent",
+			chunk: Chunk{
+				Name:       "Process",
+				ParentName: "Handler",
+			},
+			expected: "Handler.Process",
+		},
+		{
+			name: "nested method",
+			chunk: Chunk{
+				Name:       "Validate",
+				ParentName: "UserService",
+			},
+			expected: "UserService.Validate",
+		},
+
+		// ===== EDGE CASES =====
+		{
+			name: "empty name",
+			chunk: Chunk{
+				Name:       "",
+				ParentName: "",
+			},
+			expected: "",
+		},
+		{
+			name: "parent but no name",
+			chunk: Chunk{
+				Name:       "",
+				ParentName: "Parent",
+			},
+			expected: "Parent.",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := tt.chunk.Identifier()
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestChunk_LineRange(t *testing.T) {
+	tests := []struct {
+		name     string
+		expected string
+		chunk    Chunk
+	}{
+		// ===== GOOD CASES =====
+		{
+			name: "single line",
+			chunk: Chunk{
+				StartLine: 10,
+				EndLine:   10,
+			},
+			expected: "L10-L10",
+		},
+		{
+			name: "multi-line",
+			chunk: Chunk{
+				StartLine: 25,
+				EndLine:   50,
+			},
+			expected: "L25-L50",
+		},
+
+		// ===== EDGE CASES =====
+		{
+			name: "line 1",
+			chunk: Chunk{
+				StartLine: 1,
+				EndLine:   5,
+			},
+			expected: "L1-L5",
+		},
+		{
+			name: "large line numbers",
+			chunk: Chunk{
+				StartLine: 1000,
+				EndLine:   2500,
+			},
+			expected: "L1000-L2500",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := tt.chunk.LineRange()
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestChunk_SearchableContent(t *testing.T) {
+	tests := []struct {
+		name     string
+		contains []string
+		chunk    Chunk
+	}{
+		// ===== GOOD CASES =====
+		{
+			name: "full chunk with all fields",
+			chunk: Chunk{
+				Signature:  "func ProcessData(input []byte) error",
+				DocComment: "// ProcessData handles incoming data",
+				Content:    "func ProcessData(input []byte) error {\n\treturn nil\n}",
+			},
+			contains: []string{
+				"func ProcessData(input []byte) error",
+				"ProcessData handles incoming data",
+				"return nil",
+			},
+		},
+		{
+			name: "only signature",
+			chunk: Chunk{
+				Signature: "func Hello()",
+			},
+			contains: []string{"func Hello()"},
+		},
+		{
+			name: "only content",
+			chunk: Chunk{
+				Content: "some code here",
+			},
+			contains: []string{"some code here"},
+		},
+
+		// ===== EDGE CASES =====
+		{
+			name:     "empty chunk",
+			chunk:    Chunk{},
+			contains: []string{},
+		},
+		{
+			name: "only doc comment",
+			chunk: Chunk{
+				DocComment: "// Important documentation",
+			},
+			contains: []string{"Important documentation"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := tt.chunk.SearchableContent()
+			for _, expected := range tt.contains {
+				assert.Contains(t, result, expected)
+			}
+		})
+	}
+}
+
+func TestDefaultChunkOptions(t *testing.T) {
+	opts := DefaultChunkOptions()
+
+	assert.Greater(t, opts.MaxChunkSize, 0, "MaxChunkSize should be positive")
+	assert.True(t, opts.IncludeDocComments, "IncludeDocComments should be true by default")
+	assert.True(t, opts.IncludePrivate, "IncludePrivate should be true by default")
+	assert.Equal(t, 0, opts.MinLines, "MinLines should be 0 by default")
+}
+
+// =============================================================================
+// TESTS FOR ChunkType AND Language CONSTANTS
+// =============================================================================
+
+func TestChunkType_Values(t *testing.T) {
+	// Ensure all chunk types have expected values
+	assert.Equal(t, ChunkType("function"), ChunkTypeFunction)
+	assert.Equal(t, ChunkType("method"), ChunkTypeMethod)
+	assert.Equal(t, ChunkType("class"), ChunkTypeClass)
+	assert.Equal(t, ChunkType("interface"), ChunkTypeInterface)
+	assert.Equal(t, ChunkType("type"), ChunkTypeType)
+	assert.Equal(t, ChunkType("const"), ChunkTypeConst)
+	assert.Equal(t, ChunkType("var"), ChunkTypeVar)
+}
+
+func TestLanguage_Values(t *testing.T) {
+	// Ensure all language types have expected values
+	assert.Equal(t, Language("go"), LanguageGo)
+	assert.Equal(t, Language("python"), LanguagePython)
+	assert.Equal(t, Language("typescript"), LanguageTypeScript)
+	assert.Equal(t, Language("javascript"), LanguageJavaScript)
+}
@@ -0,0 +1,398 @@
+package typescript
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/lukaszraczylo/claude-mnemonic/internal/chunking"
+)
+
+// =============================================================================
+// TEST HELPERS
+// =============================================================================
+
+func createTempTSFile(t *testing.T, content string, ext string) string {
+	t.Helper()
+
+	tmpDir := t.TempDir()
+	filePath := filepath.Join(tmpDir, "test"+ext)
+
+	err := os.WriteFile(filePath, []byte(content), 0600)
+	require.NoError(t, err)
+
+	return filePath
+}
+
+// =============================================================================
+// TESTS FOR Chunker
+// =============================================================================
+
+func TestNewChunker(t *testing.T) {
+	t.Parallel()
+
+	opts := chunking.DefaultChunkOptions()
+	c := NewChunker(opts)
+
+	assert.NotNil(t, c)
+	assert.NotNil(t, c.parser)
+}
+
+func TestChunker_Language(t *testing.T) {
+	t.Parallel()
+
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	assert.Equal(t, chunking.LanguageTypeScript, c.Language())
+}
+
+func TestChunker_SupportedExtensions(t *testing.T) {
+	t.Parallel()
+
+	c := NewChunker(chunking.DefaultChunkOptions())
+	exts := c.SupportedExtensions()
+
+	assert.Contains(t, exts, ".ts")
+	assert.Contains(t, exts, ".tsx")
+	assert.Contains(t, exts, ".js")
+	assert.Contains(t, exts, ".jsx")
+}
+
+func TestChunker_Chunk_SimpleFunction(t *testing.T) {
+	t.Parallel()
+
+	code := `function greet(name: string): string {
+    return "Hello, " + name + "!";
+}
+`
+
+	filePath := createTempTSFile(t, code, ".ts")
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	require.NotEmpty(t, chunks)
+
+	// Should find the greet function
+	var foundGreet bool
+	for _, chunk := range chunks {
+		if chunk.Name == "greet" {
+			foundGreet = true
+			assert.Equal(t, chunking.ChunkTypeFunction, chunk.Type)
+			assert.Equal(t, chunking.LanguageTypeScript, chunk.Language)
+			assert.Contains(t, chunk.Content, "function greet")
+		}
+	}
+	assert.True(t, foundGreet, "Should find 'greet' function")
+}
+
+func TestChunker_Chunk_ClassWithMethods(t *testing.T) {
+	t.Parallel()
+
+	code := `class Calculator {
+    add(a: number, b: number): number {
+        return a + b;
+    }
+
+    multiply(a: number, b: number): number {
+        return a * b;
+    }
+}
+`
+
+	filePath := createTempTSFile(t, code, ".ts")
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	require.NotEmpty(t, chunks)
+
+	// Should find the Calculator class and its methods
+	var foundClass, foundAdd, foundMultiply bool
+	for _, chunk := range chunks {
+		switch chunk.Name {
+		case "Calculator":
+			foundClass = true
+			assert.Equal(t, chunking.ChunkTypeClass, chunk.Type)
+		case "add":
+			foundAdd = true
+			assert.Equal(t, chunking.ChunkTypeMethod, chunk.Type)
+			assert.Equal(t, "Calculator", chunk.ParentName)
+		case "multiply":
+			foundMultiply = true
+			assert.Equal(t, chunking.ChunkTypeMethod, chunk.Type)
+			assert.Equal(t, "Calculator", chunk.ParentName)
+		}
+	}
+
+	assert.True(t, foundClass, "Should find 'Calculator' class")
+	assert.True(t, foundAdd, "Should find 'add' method")
+	assert.True(t, foundMultiply, "Should find 'multiply' method")
+}
+
+func TestChunker_Chunk_Interface(t *testing.T) {
+	t.Parallel()
+
+	code := `interface User {
+    id: number;
+    name: string;
+    email: string;
+}
+
+interface Authenticator {
+    login(username: string, password: string): boolean;
+    logout(): void;
+}
+`
+
+	filePath := createTempTSFile(t, code, ".ts")
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	require.NotEmpty(t, chunks)
+
+	// Should find interfaces
+	interfaceNames := make(map[string]bool)
+	for _, chunk := range chunks {
+		if chunk.Type == chunking.ChunkTypeInterface {
+			interfaceNames[chunk.Name] = true
+		}
+	}
+
+	assert.True(t, interfaceNames["User"])
+	assert.True(t, interfaceNames["Authenticator"])
+}
+
+func TestChunker_Chunk_TypeAlias(t *testing.T) {
+	t.Parallel()
+
+	code := `type UserID = string;
+
+type Handler = (event: Event) => void;
+
+type Result<T> = { success: true; data: T } | { success: false; error: Error };
+`
+
+	filePath := createTempTSFile(t, code, ".ts")
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	require.NotEmpty(t, chunks)
+
+	// Should find type aliases
+	typeNames := make(map[string]bool)
+	for _, chunk := range chunks {
+		if chunk.Type == chunking.ChunkTypeType {
+			typeNames[chunk.Name] = true
+		}
+	}
+
+	assert.True(t, typeNames["UserID"])
+	assert.True(t, typeNames["Handler"])
+	assert.True(t, typeNames["Result"])
+}
+
+func TestChunker_Chunk_ArrowFunction(t *testing.T) {
+	t.Parallel()
+
+	code := `const add = (a: number, b: number): number => a + b;
+
+const greet = (name: string): string => {
+    return "Hello, " + name;
+};
+`
+
+	filePath := createTempTSFile(t, code, ".ts")
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	_, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	// Arrow functions may or may not be captured depending on AST structure
+	// At minimum, no error should occur
+}
+
+func TestChunker_Chunk_FileNotFound(t *testing.T) {
+	t.Parallel()
+
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	_, err := c.Chunk(context.Background(), "/nonexistent/path/file.ts")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "read file")
+}
+
+func TestChunker_Chunk_EmptyFile(t *testing.T) {
+	t.Parallel()
+
+	filePath := createTempTSFile(t, "", ".ts")
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	assert.Empty(t, chunks)
+}
+
+func TestChunker_Chunk_OnlyComments(t *testing.T) {
+	t.Parallel()
+
+	code := `// This is a comment
+/* Another comment */
+/**
+ * JSDoc comment
+ */
+`
+
+	filePath := createTempTSFile(t, code, ".ts")
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	// Comments without code should not produce chunks
+	assert.Empty(t, chunks)
+}
+
+func TestChunker_Chunk_AsyncFunction(t *testing.T) {
+	t.Parallel()
+
+	code := `async function fetchData(url: string): Promise<any> {
+    const response = await fetch(url);
+    return response.json();
+}
+
+async function processItems(items: string[]): Promise<void> {
+    for (const item of items) {
+        await process(item);
+    }
+}
+`
+
+	filePath := createTempTSFile(t, code, ".ts")
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	require.NotEmpty(t, chunks)
+
+	// Should find async functions
+	functionNames := make(map[string]bool)
+	for _, chunk := range chunks {
+		if chunk.Type == chunking.ChunkTypeFunction {
+			functionNames[chunk.Name] = true
+		}
+	}
+
+	assert.True(t, functionNames["fetchData"])
+	assert.True(t, functionNames["processItems"])
+}
+
+func TestChunker_Chunk_ExportedFunction(t *testing.T) {
+	t.Parallel()
+
+	code := `export function publicFunction(): void {
+    console.log("public");
+}
+
+export default function defaultExport(): void {
+    console.log("default");
+}
+`
+
+	filePath := createTempTSFile(t, code, ".ts")
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	require.NotEmpty(t, chunks)
+
+	// Should find exported functions
+	functionNames := make(map[string]bool)
+	for _, chunk := range chunks {
+		if chunk.Type == chunking.ChunkTypeFunction {
+			functionNames[chunk.Name] = true
+		}
+	}
+
+	assert.True(t, functionNames["publicFunction"])
+	assert.True(t, functionNames["defaultExport"])
+}
+
+func TestChunker_Chunk_JSXFile(t *testing.T) {
+	t.Parallel()
+
+	code := `function Button({ label }: { label: string }) {
+    return <button>{label}</button>;
+}
+
+function App() {
+    return (
+        <div>
+            <Button label="Click me" />
+        </div>
+    );
+}
+`
+
+	filePath := createTempTSFile(t, code, ".tsx")
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	require.NotEmpty(t, chunks)
+
+	// Should find JSX components as functions
+	functionNames := make(map[string]bool)
+	for _, chunk := range chunks {
+		if chunk.Type == chunking.ChunkTypeFunction {
+			functionNames[chunk.Name] = true
+		}
+	}
+
+	assert.True(t, functionNames["Button"])
+	assert.True(t, functionNames["App"])
+}
+
+func TestChunker_Chunk_JavaScript(t *testing.T) {
+	t.Parallel()
+
+	code := `function simpleFunc() {
+    return 42;
+}
+
+class MyClass {
+    constructor() {
+        this.value = 0;
+    }
+
+    getValue() {
+        return this.value;
+    }
+}
+`
+
+	filePath := createTempTSFile(t, code, ".js")
+	c := NewChunker(chunking.DefaultChunkOptions())
+
+	chunks, err := c.Chunk(context.Background(), filePath)
+	require.NoError(t, err)
+	require.NotEmpty(t, chunks)
+
+	// Should find JavaScript functions and classes
+	var foundFunc, foundClass bool
+	for _, chunk := range chunks {
+		if chunk.Name == "simpleFunc" {
+			foundFunc = true
+		}
+		if chunk.Name == "MyClass" {
+			foundClass = true
+		}
+	}
+
+	assert.True(t, foundFunc, "Should find 'simpleFunc' function")
+	assert.True(t, foundClass, "Should find 'MyClass' class")
+}