```diff
--- test_files/213-original.txt	2025-03-07 19:06:34
+++ test_files/213-modified.txt	2025-03-07 19:06:34
@@ -1,13 +1,13 @@
-import os
 import re
-import subprocess
 from typing import Any, Dict, List, Tuple, Union
 
+import tree_sitter_python as tspython
 from tree_sitter import Language, Parser
 
-from composio.tools.local.codeanalysis.constants import TREE_SITTER_FOLDER
 
+PY_LANGUAGE = Language(tspython.language())
 
+
 class Span:
     """
     Represents a span of text with start and end positions.
@@ -106,6 +106,37 @@
     raise TypeError(f"Input must be str or bytes, not {type(s).__name__}")
 
 
+def chunk_default(file_content: str, max_chunk_size: int) -> List[Span]:
+    """
+    Default chunking function for non-Python files.
+    """
+
+    def find_end_line(start_line: int, file_content: str) -> int:
+        """
+        Find the end line for a given start line in the file content.
+        """
+        end_line = start_line
+        curr_chunk_size = 0
+        lines = file_content.splitlines()
+        while end_line < len(lines) and curr_chunk_size < max_chunk_size:
+            curr_chunk_size += len(lines[end_line])
+            end_line += 1
+        return end_line
+
+    curr_chunk = Span(0, 0)
+    chunks = []
+    lines = file_content.splitlines()
+    while curr_chunk.start < len(lines):
+        start_line = curr_chunk.start
+        end_line = find_end_line(start_line, file_content)
+        chunks.append(Span(start_line, end_line))
+        if end_line >= len(lines):
+            break
+        curr_chunk = Span(end_line, end_line)
+
+    return chunks
+
+
 def chunker(tree, source_code_bytes, max_chunk_size=512 * 3, coalesce=50):
     """
     Chunk the abstract syntax tree (AST) of source code into manageable spans.
@@ -193,51 +224,29 @@
         language (Language): The loaded Python language for tree-sitter parsing.
 
     Methods:
-        _setup_tree_sitter(): Sets up the tree-sitter environment.
-        _load_language(): Loads the Python language for tree-sitter.
         chunk(): Chunks the given file content into smaller pieces.
     """
 
     def __init__(self, repo_dir: str):
-        self._setup_tree_sitter()
-        self.language = self._load_language()
         self.repo_dir = repo_dir
 
-    def _setup_tree_sitter(self):
-        python_repo = f"{TREE_SITTER_FOLDER}/python"
-        if not os.path.exists(python_repo):
-            subprocess.run(
-                [
-                    "git",
-                    "clone",
-                    "https://github.com/tree-sitter/tree-sitter-python",
-                    python_repo,
-                ],
-                check=True,
-            )
-
-        build_path = f"{TREE_SITTER_FOLDER}/build/python.so"
-        if not os.path.exists(build_path):
-            os.makedirs(os.path.dirname(build_path), exist_ok=True)
-            Language.build_library(build_path, [python_repo])
-
-    def _load_language(self) -> Language:
-        return Language(f"{TREE_SITTER_FOLDER}/build/python.so", "python")
-
     def chunk(
         self,
         file_content: str,
         file_path: str,
+        is_python: bool = True,
         score: float = 1.0,
         additional_metadata: Dict[str, str] = {},
         max_chunk_size: int = 512 * 3,
     ) -> Tuple[List[str], List[Dict[str, Any]], List[str]]:
-        parser = Parser()
-        parser.set_language(self.language)
-        tree = parser.parse(file_content.encode("utf-8"))
+        if is_python:
+            parser = Parser(PY_LANGUAGE)
+            tree = parser.parse(file_content.encode("utf-8"))
 
-        source_code_bytes = file_content.encode("utf-8")
-        spans = chunker(tree, source_code_bytes, max_chunk_size)
+            source_code_bytes = file_content.encode("utf-8")
+            spans = chunker(tree, source_code_bytes, max_chunk_size)
+        else:
+            spans = chunk_default(file_content, max_chunk_size)
 
         ids = [f"{file_path}:{span.start}:{span.end}" for span in spans]
         chunks = [span.extract(file_content) for span in spans]
```
