```python from tree_sitter_language_pack import parse_string

tree = parse_string("def foo(): pass", "python") root = tree.root_node

print(f"Root kind: {root.kind}") # "module" print(f"Start point: {root.start_point}") # (0, 0) — line, column print(f"End point: {root.end_point}") # (line, column) print(f"Child count: {root.child_count}") # number of direct children print(f"Has error: {root.has_error}") # True if any error nodes inside

Access children¶

for i in range(root.child_count): child = root.child(i) print(f"Child {i}: {child.kind}") ```

```typescript import { parseString } from "@kreuzberg/tree-sitter-language-pack";

const tree = await parseString("function foo() {}", "javascript"); const root = tree.rootNode;

console.log(Root kind: ${root.kind}); // "program" console.log(Start point: (${root.startPosition.row}, ${root.startPosition.column})); console.log(End point: (${root.endPosition.row}, ${root.endPosition.column})); console.log(Child count: ${root.childCount}); console.log(Has errors: ${root.hasError});

// Access children for (let i = 0; i < root.childCount; i++) { const child = root.child(i); console.log(Child ${i}: ${child.kind}); } ```

```rust use ts_pack_core::parse_string;

let tree = parse_string("fn foo() {}", "rust")?; let root = tree.root_node();

println!("Root kind: {}", root.kind()); println!("Start: {:?}", root.start_point()); println!("End: {:?}", root.end_point()); println!("Child count: {}", root.child_count()); println!("Has error: {}", root.has_error());

// Iterate over children for i in 0..root.child_count() { if let Some(child) = root.child(i) { println!("Child {}: {}", i, child.kind()); } } ```

```python from tree_sitter_language_pack import parse_string

tree = parse_string(""" def greet(name): print(f"Hello {name}") """, "python")

root = tree.root_node func_def = root.child(0) # First child: function_definition

Navigate deeper¶

name_node = func_def.child_by_field_name("name") params_node = func_def.child_by_field_name("parameters") body_node = func_def.child_by_field_name("body")

print(f"Function name node: {name_node.text.decode()}") # "greet" print(f"Parameters: {params_node.text.decode()}") # "(name)" print(f"Body: {body_node.text.decode()}") # "print(...)" ```

```typescript import { parseString } from "@kreuzberg/tree-sitter-language-pack";

const tree = await parseString(function greet(name) { console.log(\Hello \${name}`); } `, "javascript");

const root = tree.rootNode; const funcDecl = root.child(0); // First child: function_declaration

// Navigate via field names const nameNode = funcDecl.childByFieldName("name"); const paramsNode = funcDecl.childByFieldName("parameters"); const bodyNode = funcDecl.childByFieldName("body");

console.log(Function name: ${nameNode.text}); // "greet" console.log(Parameters: ${paramsNode.text}); // "(name)" console.log(Body: ${bodyNode.text}); // "{ ... }" ```

```python from tree_sitter_language_pack import parse_string

tree = parse_string("const x = 42;", "javascript") root = tree.root_node

Get text of any node¶

text = root.text.decode("utf-8") # Tree-sitter returns bytes print(f"Root text: {text}")

For a specific child¶

first_child = root.child(0) print(f"First child text: {first_child.text.decode()}") ```

```typescript import { parseString } from "@kreuzberg/tree-sitter-language-pack";

const tree = await parseString("const x = 42;", "javascript"); const root = tree.rootNode;

// Get text of any node console.log(Root text: ${root.text});

// For a specific child const firstChild = root.child(0); console.log(First child text: ${firstChild.text}); ```

```python from tree_sitter_language_pack import parse_string

Invalid Python: missing closing paren¶

tree = parse_string("print('hello'", "python")

No exception thrown, but the tree has error markers¶

print(f"Has errors: {tree.root_node.has_error}") # True

Find error nodes¶

def find_errors(node, errors=None): if errors is None: errors = [] if node.kind == "ERROR": errors.append(node) for i in range(node.child_count): find_errors(node.child(i), errors) return errors

errors = find_errors(tree.root_node) for err in errors: line, col = err.start_point print(f"Error at line {line}, col {col}: {err.text.decode()}") ```

```typescript import { parseString } from "@kreuzberg/tree-sitter-language-pack";

// Invalid JavaScript: missing closing brace const tree = await parseString("function foo() {", "javascript");

// No exception thrown, but the tree has error markers console.log(Has errors: ${tree.rootNode.hasError}); // true

// Find error nodes function findErrors(node, errors = []) { if (node.kind === "ERROR") { errors.push(node); } for (let i = 0; i < node.childCount; i++) { findErrors(node.child(i), errors); } return errors; }

const errors = findErrors(tree.rootNode); errors.forEach(err => { const { row, column } = err.startPosition; console.log(Error at line ${row}, col ${column}: ${err.text}); }); ```

```python from tree_sitter_language_pack import parse_string

def validate_syntax(source: str, language: str) -> tuple[bool, list[str]]: """Validate syntax and return (is_valid, error_messages).""" try: tree = parse_string(source, language) except Exception as e: return False, [str(e)]

if tree.root_node.has_error:
    return False, ["Syntax errors detected"]

return True, []

is_valid, msgs = validate_syntax("def foo():", "python") if not is_valid: print("Syntax invalid:", msgs) ```

```typescript import { parseString } from "@kreuzberg/tree-sitter-language-pack";

async function validateSyntax(source: string, language: string): Promise<[boolean, string[]]> { try { const tree = await parseString(source, language); if (tree.rootNode.hasError) { return [false, ["Syntax errors detected"]]; } return [true, []]; } catch (err) { return [false, [String(err)]]; } }

const [isValid, msgs] = await validateSyntax("const x = ", "javascript"); if (!isValid) { console.log("Syntax invalid:", msgs); } ```

```python from tree_sitter_language_pack import parse_string

tree = parse_string("if x > 5: y = 10", "python") print(tree.root_node.sexp()) ```

Output: (module (if_statement condition: (comparison left: (identifier) operator: (comparison_operator) right: (integer)) consequence: (block (assignment left: (identifier) right: (integer)))))

```typescript import { parseString } from "@kreuzberg/tree-sitter-language-pack";

const tree = await parseString("if (x > 5) { y = 10; }", "javascript"); console.log(tree.rootNode.toString()); ```

Output: (program (if_statement condition: (binary_expression left: (identifier) operator: ">" right: (number)) consequence: (block (expression_statement (assignment_expression left: (identifier) right: (number))))))

```bash ts-pack parse example.py

Or as JSON¶

ts-pack parse example.py --format json ```

```python from tree_sitter_language_pack import parse_string

tree = parse_string(""" def add(a, b): return a + b

def multiply(a, b): return a * b """, "python")

def walk_tree(node): """Recursively visit all nodes in the tree.""" yield node for i in range(node.child_count): child = node.child(i) yield from walk_tree(child)

Count all nodes¶

node_count = sum(1 for _ in walk_tree(tree.root_node)) print(f"Total nodes: {node_count}")

Find all function definitions¶

func_defs = [node for node in walk_tree(tree.root_node) if node.kind == "function_definition"] for func in func_defs: name = func.child_by_field_name("name").text.decode() print(f"Function: {name}") ```

```typescript import { parseString } from "@kreuzberg/tree-sitter-language-pack";

const tree = await parseString(` function add(a, b) { return a + b; }

function multiply(a, b) { return a * b; } `, "javascript");

function walkTree(node) { yield node; for (let i = 0; i < node.childCount; i++) { yield walkTree(node.child(i)); } }

// Count all nodes let count = 0; for (const _ of walkTree(tree.rootNode)) { count++; } console.log(Total nodes: ${count});

// Find all function declarations const funcDecls = []; for (const node of walkTree(tree.rootNode)) { if (node.kind === "function_declaration") { funcDecls.push(node); } } funcDecls.forEach(func => { const name = func.childByFieldName("name").text; console.log(Function: ${name}); }); ```

```python from tree_sitter_language_pack import parse_string

source = """ def outer(): def inner(): pass return inner

class MyClass: def method(self): pass """

tree = parse_string(source, "python")

def count_by_kind(node, kind): count = 0 def walk(n): nonlocal count if n.kind == kind: count += 1 for i in range(n.child_count): walk(n.child(i)) walk(node) return count

funcs = count_by_kind(tree.root_node, "function_definition") classes = count_by_kind(tree.root_node, "class_definition") print(f"Functions: {funcs}, Classes: {classes}")

Output: Functions: 3, Classes: 1¶

```

```python from tree_sitter_language_pack import parse_string

source = """ import os from pathlib import Path import sys as system """

tree = parse_string(source, "python")

imports = [] def find_imports(node): if node.kind in ("import_statement", "import_from_statement"): imports.append(node.text.decode()) for i in range(node.child_count): find_imports(node.child(i))

find_imports(tree.root_node) for imp in imports: print(imp) ```