### Get Root Directory with Path::getRoot

Source: https://context7.com/symfony/filesystem/llms.txt

Returns the root directory of a given path, supporting UNIX, Windows, and stream wrapper roots.

```php
<?php
use Symfony\Component\Filesystem\Path;

echo Path::getRoot('/var/www/app');
// Output: /

echo Path::getRoot('C:/Users/App');
// Output: C:/

echo Path::getRoot('phar:///app.phar/src');
// Output: phar:///

echo Path::getRoot('relative/path');
// Output: (empty string)
```

--------------------------------

### Convert to Relative Path with makePathRelative

Source: https://context7.com/symfony/filesystem/llms.txt

Converts an absolute path to a relative path from a given start path. Handles navigation up through directories.

```php
<?php
use Symfony\Component\Filesystem\Filesystem;

$filesystem = new Filesystem();

// Get relative path between directories
$relative = $filesystem->makePathRelative(
    '/var/www/app/public/css/style.css',
    '/var/www/app/public'
);
// Returns: css/style.css/

// Navigate up directories
$relative = $filesystem->makePathRelative(
    '/var/www/shared/assets',
    '/var/www/app/public'
);
// Returns: ../../shared/assets/
```

--------------------------------

### Get User Home Directory

Source: https://context7.com/symfony/filesystem/llms.txt

Retrieve the canonicalized path to the user's home directory using `Path::getHomeDirectory()`. This method throws a `RuntimeException` if the directory cannot be determined.

```php
<?php
use Symfony\Component\Filesystem\Path;
use Symfony\Component\Filesystem\Exception\RuntimeException;

try {
    $home = Path::getHomeDirectory();
    // UNIX: /home/username or /Users/username
    // Windows: C:/Users/username

    echo "Home directory: $home";
} catch (RuntimeException $e) {
    echo 'Could not determine home directory: ' . $e->getMessage();
}
```

--------------------------------

### Filesystem::makePathRelative

Source: https://context7.com/symfony/filesystem/llms.txt

Given two absolute paths, returns a relative path from the start path to the end path.

```APIDOC
## makePathRelative - Convert to Relative Path

### Description
Given two absolute paths, returns a relative path from the start path to the end path.

### Method
`makePathRelative`

### Parameters
#### Path Parameters
- **startPath** (string) - Required - The starting absolute path.
- **endPath** (string) - Required - The ending absolute path.

### Request Example
```php
use Symfony\Component\Filesystem\Filesystem;

$filesystem = new Filesystem();
$relative = $filesystem->makePathRelative('/var/www/app/public/css/style.css', '/var/www/app/public');
$relativeUp = $filesystem->makePathRelative('/var/www/shared/assets', '/var/www/app/public');
```

### Response
#### Success Response (string)
- The relative path from `startPath` to `endPath`.

#### Response Example
```
css/style.css/
../../shared/assets/
```
```

--------------------------------

### Get File Extension in PHP

Source: https://context7.com/symfony/filesystem/llms.txt

Retrieves the file extension without the leading dot, with an option to force lowercase output.

```php
<?php
use Symfony\Component\Filesystem\Path;

echo Path::getExtension('/var/www/app/config.php');
// Output: php

echo Path::getExtension('/var/www/app/styles.CSS', true);
// Output: css (forced lowercase)

echo Path::getExtension('/var/www/app/archive.tar.gz');
// Output: gz
```

--------------------------------

### Get Filename Without Extension in PHP

Source: https://context7.com/symfony/filesystem/llms.txt

Extracts the filename from a path, optionally stripping a specific extension.

```php
<?php
use Symfony\Component\Filesystem\Path;

echo Path::getFilenameWithoutExtension('/var/www/app/config.php');
// Output: config

echo Path::getFilenameWithoutExtension('/var/www/app/archive.tar.gz');
// Output: archive.tar

// Remove specific extension
echo Path::getFilenameWithoutExtension('/var/www/app/archive.tar.gz', '.gz');
// Output: archive.tar

echo Path::getFilenameWithoutExtension('/var/www/app/archive.tar.gz', '.tar.gz');
// Output: archive
```

--------------------------------

### Get Directory Part with Path::getDirectory

Source: https://context7.com/symfony/filesystem/llms.txt

Returns the directory portion of a path, handling edge cases that PHP's dirname() might not.

```php
<?php
use Symfony\Component\Filesystem\Path;

echo Path::getDirectory('/var/www/app/config.php');
// Output: /var/www/app

echo Path::getDirectory('/var/www/app/');
// Output: /var/www/app

echo Path::getDirectory('config.php');
// Output: (empty string)

echo Path::getDirectory('C:/symfony');
// Output: C:/

echo Path::getDirectory('/');
// Output: /
```

--------------------------------

### Filesystem Class - mkdir

Source: https://context7.com/symfony/filesystem/llms.txt

Creates one or more directories recursively. Throws IOException if directory creation fails.

```APIDOC
## POST /filesystem/mkdir

### Description
Creates one or more directories recursively, similar to `mkdir -p`. Throws `IOException` if directory creation fails.

### Method
POST

### Endpoint
/filesystem/mkdir

### Parameters
#### Request Body
- **paths** (array|string) - Required - The path(s) to the directory/directories to create.
- **permissions** (integer) - Optional - The octal permissions to set for the created directories. Defaults to `0777`.

### Request Example
```json
{
  "paths": [
    "/var/www/app/cache",
    "/var/www/app/logs"
  ],
  "permissions": 448
}
```

### Response
#### Success Response (200)
Indicates successful creation of directories.

#### Response Example
```json
{
  "message": "Directories created successfully."
}
```
```

--------------------------------

### Create Directories with mkdir

Source: https://context7.com/symfony/filesystem/llms.txt

Creates directories recursively, supporting single paths, arrays of paths, and custom octal permissions. Throws an IOException on failure.

```php
<?php
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Filesystem\Exception\IOException;

$filesystem = new Filesystem();

try {
    // Create a single directory
    $filesystem->mkdir('/var/www/app/cache');

    // Create multiple directories at once
    $filesystem->mkdir([
        '/var/www/app/logs',
        '/var/www/app/uploads',
        '/var/www/app/sessions'
    ]);

    // Create with specific permissions (octal)
    $filesystem->mkdir('/var/www/app/private', 0o700);
} catch (IOException $e) {
    echo 'Failed to create directory: ' . $e->getMessage();
    echo 'Path: ' . $e->getPath();
}
```

--------------------------------

### Create Symbolic Links with symlink

Source: https://context7.com/symfony/filesystem/llms.txt

Creates a symbolic link. On Windows, setting the third parameter to true allows copying the directory instead of creating a link, which avoids the need for admin privileges.

```php
<?php
use Symfony\Component\Filesystem\Filesystem;
use Symfony\
Component\Filesystem\Exception\IOException;

$filesystem = new Filesystem();

try {
    // Create a symbolic link
    $filesystem->symlink('/var/www/shared/assets', '/var/www/app/public/assets');

    // On Windows, copy instead of creating symlink (no admin rights needed)
    $filesystem->symlink('/var/www/shared/assets', '/var/www/app/public/assets', true);
} catch (IOException $e) {
    echo 'Symlink failed: ' . $e->getMessage();
}
```

--------------------------------

### mirror - Mirror a Directory

Source: https://context7.com/symfony/filesystem/llms.txt

Copies an entire directory structure to another location with support for overwriting, symlinks, and deletion.

```APIDOC
## mirror

### Description
Copies an entire directory structure to another location. Supports options for overwriting, following symlinks, and deleting extra files in target.

### Parameters
- **originDir** (string) - Required - The source directory path.
- **targetDir** (string) - Required - The destination directory path.
- **iterator** (Traversable|null) - Optional - Custom iterator for filtering files.
- **options** (array) - Optional - Configuration options: 'override' (bool), 'follow_symlinks' (bool), 'delete' (bool).
```

--------------------------------

### symlink - Create Symbolic Links

Source: https://context7.com/symfony/filesystem/llms.txt

Creates a symbolic link. On Windows, it can optionally copy the directory instead.

```APIDOC
## symlink - Create Symbolic Links

### Description
Creates a symbolic link. On Windows with `$copyOnWindows` set to true, copies the directory instead (requires admin rights for symlinks).

### Method
`symlink`

### Parameters
#### Path Parameters
- **target** (string) - Required - The target path of the link.
- **link** (string) - Required - The path where the link will be created.
- **copyOnWindows** (bool) - Optional - If true, copies the directory on Windows instead of creating a symlink.

### Request Example
```php
use Symfony\Component\Filesystem\Filesystem;

$filesystem = new Filesystem();
$filesystem->symlink('/var/www/shared/assets', '/var/www/app/public/assets');
$filesystem->symlink('/var/www/shared/assets', '/var/www/app/public/assets', true); // On Windows, copy instead
```

### Response
This method does not return a value upon success. Exceptions are thrown on failure.
```

--------------------------------

### Copy Files with copy

Source: https://context7.com/symfony/filesystem/llms.txt

Copies files from source to destination, with optional overwriting of newer files and support for remote URLs.

```php
<?php
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Filesystem\Exception\FileNotFoundException;
use Symfony\Component\Filesystem\Exception\IOException;

$filesystem = new Filesystem();

try {
    // Basic copy - won't overwrite if target is newer
    $filesystem->copy('/path/to/source.txt', '/path/to/destination.txt');

    // Force overwrite even if target is newer
    $filesystem->copy('/path/to/source.txt', '/path/to/destination.txt', true);

    // Copy from remote URL
    $filesystem->copy('https://example.com/file.pdf', '/local/path/file.pdf');
} catch (FileNotFoundException $e) {
    echo 'Source file not found: ' . $e->getPath();
} catch (IOException $e) {
    echo 'Copy failed: ' . $e->getMessage();
}
```

--------------------------------

### Filesystem::tempnam

Source: https://context7.com/symfony/filesystem/llms.txt

Creates a temporary file with support for custom stream wrappers and suffixes.

```APIDOC
## tempnam - Create Temporary File

### Description
Creates a temporary file with support for custom stream wrappers and suffixes.

### Method
`tempnam`

### Parameters
#### Path Parameters
- **dir** (string) - Required - The directory where the temporary file will be created.
- **prefix** (string) - Required - The prefix for the temporary file name.
- **suffix** (string) - Optional - The suffix for the temporary file name.

### Request Example
```php
use Symfony\Component\Filesystem\Filesystem;

$filesystem = new Filesystem();
$tempFile = $filesystem->tempnam(sys_get_temp_dir(), 'app_');
$tempFileWithSuffix = $filesystem->tempnam('/var/www/app/cache', 'cache_', '.tmp');
```

### Response
#### Success Response (string)
- The absolute path to the created temporary file.

#### Response Example
```
/tmp/app_a1b2c3d4
/var/www/app/cache/cache_a1b2c3d4.tmp
```

### Error Handling
- Throws `IOException` if the file cannot be created.
```

--------------------------------

### Path::join

Source: https://context7.com/symfony/filesystem/llms.txt

Joins multiple path strings into a single canonical path.

```APIDOC
## join - Join Path Segments

### Description
Joins multiple path strings into a single canonical path.

### Method
`Path::join`

### Parameters
#### Path Parameters
- **segments** (array of strings) - Required - The path segments to join.

### Request Example
```php
use Symfony\Component\Filesystem\Path;

$joinedPath = Path::join('/var/www', 'app', 'config');
$joinedWithSlashes = Path::join('/var/www/', '/app/', 'config');
$joinedWithDots = Path::join('/var/www', '..', 'app', './config');
$joinedStream = Path::join('phar://', '/app.phar', 'src/file.php');
```

### Response
#### Success Response (string)
- The joined canonical path.

#### Response Example
```
/var/www/app/config
/var/www/app/config
/var/app/config
phar:///app.phar/src/file.php
```
```

--------------------------------

### Create Temporary File with tempnam

Source: https://context7.com/symfony/filesystem/llms.txt

Use tempnam to create a temporary file in a specified directory with custom prefixes and suffixes. Handles potential IO exceptions during file creation.

```php
<?php
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Filesystem\Exception\IOException;

$filesystem = new Filesystem();

try {
    // Create temp file in system temp directory
    $tempFile = $filesystem->tempnam(sys_get_temp_dir(), 'app_');
    // Returns: /tmp/app_a1b2c3d4

    // Create temp file with specific suffix
    $tempFile = $filesystem->tempnam('/var/www/app/cache', 'cache_', '.tmp');
    // Returns: /var/www/app/cache/cache_a1b2c3d4.tmp

    // Use the temp file
    file_put_contents($tempFile, 'temporary data');

    // Clean up
    $filesystem->remove($tempFile);
} catch (IOException $e) {
    echo 'Failed to create temp file: ' . $e->getMessage();
}
```

--------------------------------

### Atomically Write File Content with dumpFile

Source: https://context7.com/symfony/filesystem/llms.txt

Writes content to a file atomically by writing to a temporary file first and then renaming it. Parent directories are created automatically if they do not exist.

```php
<?php
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Filesystem\Exception\IOException;

$filesystem = new Filesystem();

try {
    // Write string content
    $filesystem->dumpFile('/var/www/app/config/parameters.json', json_encode([
        'database' => 'mysql://localhost/app',
        'debug' => false
    ], JSON_PRETTY_PRINT));

    // Write from a stream resource
    $resource = fopen('php://memory', 'r+');
    fwrite($resource, 'Stream content here');
    rewind($resource);
    $filesystem->dumpFile('/path/to/output.txt', $resource);
    fclose($resource);
} catch (IOException $e) {
    echo 'Failed to write file: ' . $e->getMessage();
}
```

--------------------------------

### Filesystem Class - copy

Source: https://context7.com/symfony/filesystem/llms.txt

Copies a file from origin to target. By default, newer target files are not overwritten unless `$overwriteNewerFiles` is set to `true`.

```APIDOC
## POST /filesystem/copy

### Description
Copies a file from origin to target. By default, newer target files are not overwritten unless `overwriteNewerFiles` is set to `true`.

### Method
POST

### Endpoint
/filesystem/copy

### Parameters
#### Request Body
- **origin** (string) - Required - The path to the source file.
- **target** (string) - Required - The path to the destination file.
- **overwriteNewerFiles** (boolean) - Optional - If set to `true`, the target file will be overwritten even if it is newer than the origin file. Defaults to `false`.

### Request Example
```json
{
  "origin": "/path/to/source.txt",
  "target": "/path/to/destination.txt",
  "overwriteNewerFiles": true
}
```

### Response
#### Success Response (200)
Indicates successful file copy.

#### Response Example
```json
{
  "message": "File copied successfully."
}
```
```

--------------------------------

### touch - Set File Timestamps

Source: https://context7.com/symfony/filesystem/llms.txt

Sets access and modification time of files, creating the file if it does not exist.

```APIDOC
## touch

### Description
Sets access and modification time of files. Creates the file if it doesn't exist.

### Parameters
- **files** (string|iterable) - Required - Path or list of paths to files.
- **time** (int) - Optional - Modification time.
- **atime** (int) - Optional - Access time.
```

--------------------------------

### Convert to Relative Path in PHP

Source: https://context7.com/symfony/filesystem/llms.txt

Calculates the relative path from a base path to a target path.

```php
<?php
use Symfony\Component\Filesystem\Path;

echo Path::makeRelative('/var/www/app/config.php', '/var/www');
// Output: app/config.php

echo Path::makeRelative('/var/www/shared/assets', '/var/www/app/public');
// Output: ../../shared/assets

echo Path::makeRelative('/var/www/app', '/var/www/app');
// Output: (empty string - same directory)
```

--------------------------------

### Create Hard Links with hardlink

Source: https://context7.com/symfony/filesystem/llms.txt

Creates one or more hard links to a file. Hard links share the same inode and data blocks.

```php
<?php
use Symfony\
Component\Filesystem\Filesystem;
use Symfony\Component\Filesystem\Exception\FileNotFoundException;
use Symfony\Component\Filesystem\Exception\IOException;

$filesystem = new Filesystem();

try {
    // Create a single hard link
    $filesystem->hardlink('/path/to/original.txt', '/path/to/hardlink.txt');

    // Create multiple hard links to the same file
    $filesystem->hardlink('/path/to/original.txt', [
        '/path/to/link1.txt',
        '/path/to/link2.txt',
        '/path/to/link3.txt'
    ]);
} catch (FileNotFoundException $e) {
    echo 'Original file not found: ' . $e->getPath();
} catch (IOException $e) {
    echo 'Hardlink failed: ' . $e->getMessage();
}
```

--------------------------------

### Path::getHomeDirectory

Source: https://context7.com/symfony/filesystem/llms.txt

Retrieves the canonicalized path to the current user's home directory.

```APIDOC
## Path::getHomeDirectory

### Description
Returns the canonicalized path to the user's home directory.

### Response
- **string** - The absolute path to the home directory.

### Errors
- **RuntimeException** - Thrown if the home directory cannot be determined.
```

--------------------------------

### Read File Content with readFile

Source: https://context7.com/symfony/filesystem/llms.txt

Reads and returns the entire contents of a file as a string.

```php
<?php
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Filesystem\Exception\IOException;

$filesystem = new Filesystem();

try {
    // Read file content
    $content = $filesystem->readFile('/var/www/app/config/settings.json');
    $settings = json_decode($content, true);

    // Process content
    echo 'App name: ' . $settings['app_name'];
} catch (IOException $e) {
    echo 'Failed to read file: ' . $e->getMessage();
}
```

--------------------------------

### Filesystem Class - exists

Source: https://context7.com/symfony/filesystem/llms.txt

Checks whether one or more files or directories exist. Returns true only if all specified paths exist.

```APIDOC
## GET /filesystem/exists

### Description
Checks whether one or more files or directories exist. Returns `true` only if all specified paths exist.

### Method
GET

### Endpoint
/filesystem/exists

### Parameters
#### Query Parameters
- **paths** (array|string) - Required - The path(s) to the file(s) or directory(ies) to check.

### Request Example
```
GET /filesystem/exists?paths[]=/var/www/app/config.php&paths[]=/var/www/app/.env
```

### Response
#### Success Response (200)
- **exists** (boolean) - `true` if all specified paths exist, `false` otherwise.

#### Response Example
```json
{
  "exists": true
}
```
```

--------------------------------

### Check File Extension in PHP

Source: https://context7.com/symfony/filesystem/llms.txt

Verifies if a path contains a specific extension or any extension at all, supporting case-insensitive checks and multiple extension arrays.

```php
<?php
use Symfony\Component\Filesystem\Path;

// Check for any extension
Path::hasExtension('/var/www/app/config.php');       // true
Path::hasExtension('/var/www/app/README');           // false

// Check for specific extension
Path::hasExtension('/var/www/app/config.php', 'php');      // true
Path::hasExtension('/var/www/app/config.php', '.php');     // true (leading dot ok)
Path::hasExtension('/var/www/app/config.PHP', 'php', true); // true (case insensitive)

// Check for multiple extensions
Path::hasExtension('/var/www/app/image.png', ['jpg', 'png', 'gif']); // true
```

--------------------------------

### Filesystem Class - rename

Source: https://context7.com/symfony/filesystem/llms.txt

Renames a file or directory. Can also move files across directories. Throws exception if target exists unless `$overwrite` is `true`.

```APIDOC
## PUT /filesystem/rename

### Description
Renames a file or directory. Can also move files across directories. Throws exception if target exists unless `overwrite` is `true`.

### Method
PUT

### Endpoint
/filesystem/rename

### Parameters
#### Request Body
- **origin** (string) - Required - The current name/path of the file or directory.
- **target** (string) - Required - The new name/path for the file or directory.
- **overwrite** (boolean) - Optional - If set to `true`, the target will be overwritten if it exists. Defaults to `false`.

### Request Example
```json
{
  "origin": "/path/to/old-name.txt",
  "target": "/path/to/new-name.txt",
  "overwrite": true
}
```

### Response
#### Success Response (200)
Indicates successful renaming or moving of the file or directory.

#### Response Example
```json
{
  "message": "Item renamed/moved successfully."
}
```
```

--------------------------------

### Convert to Absolute Path in PHP

Source: https://context7.com/symfony/filesystem/llms.txt

Resolves a relative path into an absolute path using a provided base path.

```php
<?php
use Symfony\Component\Filesystem\Path;

echo Path::makeAbsolute('config/app.php', '/var/www');
// Output: /var/www/config/app.php

echo Path::makeAbsolute('../shared/assets', '/var/www/app/public');
// Output: /var/www/app/shared/assets

// Already absolute paths are just canonicalized
echo Path::makeAbsolute('/etc/config', '/var/www');
// Output: /etc/config
```

--------------------------------

### Path::getRoot

Source: https://context7.com/symfony/filesystem/llms.txt

Returns the root directory of a path.

```APIDOC
## getRoot - Get Root Directory

### Description
Returns the root directory of a path.

### Method
`Path::getRoot`

### Parameters
#### Path Parameters
- **path** (string) - Required - The path to get the root directory from.

### Request Example
```php
use Symfony\Component\Filesystem\Path;

$root1 = Path::getRoot('/var/www/app');
$root2 = Path::getRoot('C:/Users/App');
$root3 = Path::getRoot('phar:///app.phar/src');
$root4 = Path::getRoot('relative/path');
```

### Response
#### Success Response (string)
- The root directory of the path.

#### Response Example
```
/
C:/
phar:///
(empty string)
```
```

--------------------------------

### Set File Timestamps

Source: https://context7.com/symfony/filesystem/llms.txt

Updates access and modification times for files. Creates the file if it does not exist.

```php
<?php
use Symfony\
Component\Filesystem\Filesystem;
use Symfony\Component\Filesystem\Exception\IOException;

$filesystem = new Filesystem();

try {
    // Touch with current timestamp
    $filesystem->touch('/var/www/app/cache/.gitkeep');

    // Touch multiple files
    $filesystem->touch(['/path/file1.txt', '/path/file2.txt']);

    // Set specific modification time
    $filesystem->touch('/path/to/file.txt', strtotime('2024-01-15'));

    // Set both modification and access time
    $modTime = strtotime('2024-01-15');
    $accessTime = strtotime('2024-01-20');
    $filesystem->touch('/path/to/file.txt', $modTime, $accessTime);
} catch (IOException $e) {
    echo 'Touch failed: ' . $e->getMessage();
}
```

--------------------------------

### Mirror a Directory

Source: https://context7.com/symfony/filesystem/llms.txt

Copies directory structures with options for overwriting, symlink handling, and deletion. Supports custom iterators for filtering files.

```php
<?php
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Filesystem\Exception\IOException;

$filesystem = new Filesystem();

try {
    // Basic mirror - copies all files
    $filesystem->mirror('/source/directory', '/target/directory');

    // Mirror with options
    $filesystem->mirror('/source/directory', '/target/directory', null, [
        'override' => true,           // Overwrite newer files in target
        'follow_symlinks' => true,    // Copy files instead of symlinks (useful on Windows)
        'delete' => true              // Delete files in target not present in source
    ]);

    // Mirror with custom iterator (filter specific files)
    $iterator = new \RecursiveIteratorIterator(
        new \RecursiveCallbackFilterIterator(
            new \RecursiveDirectoryIterator('/source/directory', \FilesystemIterator::SKIP_DOTS),
            function ($current) {
                // Only include PHP files
                return $current->isDir() || $current->getExtension() === 'php';
            }
        ),
        \RecursiveIteratorIterator::SELF_FIRST
    );
    $filesystem->mirror('/source/directory', '/target/directory', $iterator);
} catch (IOException $e) {
    echo 'Mirror failed: ' . $e->getMessage();
}
```

--------------------------------

### Normalize Path with Path::canonicalize

Source: https://context7.com/symfony/filesystem/llms.txt

Normalizes a path by resolving '.' and '..' segments and converting Windows backslashes to forward slashes. Also resolves the home directory '~'.

```php
<?php
use Symfony\Component\Filesystem\Path;

// Resolve . and .. segments
echo Path::canonicalize('/var/www/../app/./config');
// Output: /var/www/config

// Resolve home directory
echo Path::canonicalize('~/projects/app');
// Output: /home/user/projects/app

// Windows path normalization
echo Path::canonicalize('C:\\Users\\App\\..\\Config');
// Output: C:/Users/Config
```

--------------------------------

### Join Path Segments with Path::join

Source: https://context7.com/symfony/filesystem/llms.txt

Joins multiple path strings into a single canonical path, handling trailing slashes, resolving '.' and '..' segments, and working with stream wrappers.

```php
<?php
use Symfony\Component\Filesystem\Path;

// Join path segments
echo Path::join('/var/www', 'app', 'config');
// Output: /var/www/app/config

// Handles trailing slashes
echo Path::join('/var/www/', '/app/', 'config');
// Output: /var/www/app/config

// Resolves . and .. during join
echo Path::join('/var/www', '..', 'app', './config');
// Output: /var/app/config

// Works with stream wrappers
echo Path::join('phar://', '/app.phar', 'src/file.php');
// Output: phar:///app.phar/src/file.php
```

--------------------------------

### Remove Files and Directories with remove

Source: https://context7.com/symfony/filesystem/llms.txt

Deletes files, directories, or symbolic links. Directories are processed recursively.

```php
<?php
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Filesystem\Exception\IOException;

$filesystem = new Filesystem();

try {
    // Remove a single file
    $filesystem->remove('/var/www/app/cache/temp.cache');

    // Remove a directory and all its contents
    $filesystem->remove('/var/www/app/cache');

    // Remove multiple items at once
    $filesystem->remove([
        '/var/www/app/logs/old.log',
        '/var/www/app/cache',
        '/var/www/app/sessions'
    ]);
} catch (IOException $e) {
    echo 'Removal failed: ' . $e->getMessage();
}
```

--------------------------------

### Path::isAbsolute and Path::isRelative

Source: https://context7.com/symfony/filesystem/llms.txt

Determine whether a path is absolute or relative.

```APIDOC
## Path::isAbsolute / Path::isRelative

### Description
Determine whether a path is absolute or relative.

### Parameters
#### Arguments
- **path** (string) - Required - The path to check.
```

--------------------------------

### Filesystem Class - remove

Source: https://context7.com/symfony/filesystem/llms.txt

Removes files, directories, or symbolic links. Directories are removed recursively.

```APIDOC
## DELETE /filesystem/remove

### Description
Removes files, directories, or symbolic links. Directories are removed recursively.

### Method
DELETE

### Endpoint
/filesystem/remove

### Parameters
#### Request Body
- **paths** (array|string) - Required - The path(s) to the file(s), directory(ies), or symbolic link(s) to remove.

### Request Example
```json
{
  "paths": [
    "/var/www/app/cache/temp.cache",
    "/var/www/app/cache"
  ]
}
```

### Response
#### Success Response (200)
Indicates successful removal of files and directories.

#### Response Example
```json
{
  "message": "Items removed successfully."
}
```
```

--------------------------------

### Check Existence with exists

Source: https://context7.com/symfony/filesystem/llms.txt

Verifies if one or more paths exist. Returns true only if every path provided in the input array is present.

```php
<?php
use Symfony\Component\Filesystem\Filesystem;

$filesystem = new Filesystem();

// Check single file
if ($filesystem->exists('/var/www/app/config.php')) {
    echo 'Config file exists';
}

// Check multiple files - returns true only if ALL exist
if ($filesystem->exists(['/var/www/app/config.php', '/var/www/app/.env'])) {
    echo 'Both configuration files exist';
}
```

--------------------------------

### Path::getExtension

Source: https://context7.com/symfony/filesystem/llms.txt

Returns the file extension without the leading dot.

```APIDOC
## Path::getExtension

### Description
Returns the file extension without the leading dot.

### Parameters
#### Arguments
- **path** (string) - Required - The file path.
- **forceLowercase** (bool) - Optional - Whether to force the extension to lowercase.
```

--------------------------------

### hardlink - Create Hard Links

Source: https://context7.com/symfony/filesystem/llms.txt

Creates one or more hard links to a file. Hard links share the same inode and data blocks.

```APIDOC
## hardlink - Create Hard Links

### Description
Creates one or more hard links to a file. Hard links share the same inode and data blocks.

### Method
`hardlink`

### Parameters
#### Path Parameters
- **target** (string) - Required - The path to the original file.
- **link** (string|array<string>) - Required - The path(s) where the hard link(s) will be created.

### Request Example
```php
use Symfony\Component\Filesystem\Filesystem;

$filesystem = new Filesystem();
$filesystem->hardlink('/path/to/original.txt', '/path/to/hardlink.txt');
$filesystem->hardlink('/path/to/original.txt', [
    '/path/to/link1.txt',
    '/path/to/link2.txt',
    '/path/to/link3.txt'
]);
```

### Response
This method does not return a value upon success. Exceptions are thrown on failure.
```

--------------------------------

### Append Content to File with appendToFile

Source: https://context7.com/symfony/filesystem/llms.txt

Appends content to an existing file or creates it if missing. Supports optional file locking for concurrent access.

```php
<?php
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Filesystem\Exception\IOException;

$filesystem = new Filesystem();

try {
    // Simple append
    $filesystem->appendToFile('/var/log/app.log', "[INFO] Application started\n");

    // Append with file locking (for concurrent access)
    $filesystem->appendToFile('/var/log/app.log', "[DEBUG] Processing request\n", true);

    // Append from resource
    $resource = fopen('php://memory', 'r+');
    fwrite($resource, 'Additional content');
    rewind($resource);
    $filesystem->appendToFile('/path/to/file.txt', $resource);
    fclose($resource);
} catch (IOException $e) {
    echo 'Failed to append to file: ' . $e->getMessage();
}
```

--------------------------------

### Check if Path is Absolute with isAbsolutePath

Source: https://context7.com/symfony/filesystem/llms.txt

Determines if a given path is absolute, supporting UNIX, Windows, and stream wrapper formats.

```php
<?php
use Symfony\Component\Filesystem\Filesystem;

$filesystem = new Filesystem();

$filesystem->isAbsolutePath('/var/www/app');     // true (UNIX absolute)
$filesystem->isAbsolutePath('C:/Users/app');     // true (Windows absolute)
$filesystem->isAbsolutePath('phar:///app.phar'); // true (stream wrapper)
$filesystem->isAbsolutePath('relative/path');    // false
$filesystem->isAbsolutePath('../parent');        // false
```

--------------------------------

### dumpFile - Atomically Write File Content

Source: https://context7.com/symfony/filesystem/llms.txt

Writes content to a file atomically by using a temporary file and then renaming it. Parent directories are created if they do not exist.

```APIDOC
## dumpFile - Atomically Write File Content

### Description
Writes content to a file atomically (writes to temp file first, then renames). Creates parent directories if needed.

### Method
`dumpFile`

### Parameters
#### Path Parameters
- **path** (string) - Required - The path to the file where content will be written.
- **content** (string|resource) - Required - The content to write to the file. Can be a string or a stream resource.

### Request Example
```php
use Symfony\Component\Filesystem\Filesystem;

$filesystem = new Filesystem();
$filesystem->dumpFile('/var/www/app/config/parameters.json', json_encode([
    'database' => 'mysql://localhost/app',
    'debug' => false
], JSON_PRETTY_PRINT));

$resource = fopen('php://memory', 'r+');
fwrite($resource, 'Stream content here');
rewind($resource);
$filesystem->dumpFile('/path/to/output.txt', $resource);
fclose($resource);
```

### Response
This method does not return a value upon success. Exceptions are thrown on failure.
```

--------------------------------

### Rename or Move Files with rename

Source: https://context7.com/symfony/filesystem/llms.txt

Renames or moves files and directories. Overwriting existing targets requires setting the third parameter to true.

```php
<?php
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Filesystem\Exception\IOException;

$filesystem = new Filesystem();

try {
    // Simple rename
    $filesystem->rename('/path/to/old-name.txt', '/path/to/new-name.txt');

    // Move to different directory
    $filesystem->rename('/downloads/file.pdf', '/documents/file.pdf');

    // Rename with overwrite if target exists
    $filesystem->rename('/path/to/source.txt', '/path/to/existing.txt', true);
} catch (IOException $e) {
    echo 'Rename failed: ' . $e->getMessage();
}
```

--------------------------------

### Path::makeAbsolute

Source: https://context7.com/symfony/filesystem/llms.txt

Converts a relative path to an absolute path based on a given base path.

```APIDOC
## Path::makeAbsolute

### Description
Converts a relative path to an absolute path based on a given base path.

### Parameters
#### Arguments
- **path** (string) - Required - The path to convert.
- **basePath** (string) - Required - The base path to use.
```

--------------------------------

### Read Link Target with readlink

Source: https://context7.com/symfony/filesystem/llms.txt

Reads the target of a symbolic link. Use the canonicalize option to return the absolute resolved path.

```php
<?php
use Symfony\Component\Filesystem\Filesystem;

$filesystem = new Filesystem();

// Get direct link target (returns null if not a link)
$target = $filesystem->readlink('/var/www/app/public/assets');
// Returns: /var/www/shared/assets (or null if not a link)

// Get canonicalized absolute path (resolves all symlinks)
$realPath = $filesystem->readlink('/var/www/app/public/assets', true);
// Returns: /var/www/shared/assets (absolute resolved path, or null if path doesn't exist)
```

--------------------------------

### Filesystem::isAbsolutePath

Source: https://context7.com/symfony/filesystem/llms.txt

Returns whether the given path is an absolute path (including URLs and stream wrappers).

```APIDOC
## isAbsolutePath - Check if Path is Absolute

### Description
Returns whether the given path is an absolute path (including URLs and stream wrappers).

### Method
`isAbsolutePath`

### Parameters
#### Path Parameters
- **path** (string) - Required - The path to check.

### Request Example
```php
use Symfony\Component\Filesystem\Filesystem;

$filesystem = new Filesystem();
$isAbsoluteUnix = $filesystem->isAbsolutePath('/var/www/app');
$isAbsoluteWindows = $filesystem->isAbsolutePath('C:/Users/app');
$isAbsoluteStream = $filesystem->isAbsolutePath('phar:///app.phar');
$isRelative = $filesystem->isAbsolutePath('relative/path');
$isRelativeParent = $filesystem->isAbsolutePath('../parent');
```

### Response
#### Success Response (boolean)
- `true` if the path is absolute, `false` otherwise.

#### Response Example
```
true
true
true
false
false
```
```

--------------------------------

### Path::changeExtension

Source: https://context7.com/symfony/filesystem/llms.txt

Changes the extension of a file path.

```APIDOC
## Path::changeExtension

### Description
Changes the extension of a file path.

### Parameters
#### Arguments
- **path** (string) - Required - The file path.
- **extension** (string) - Required - The new extension.
```

--------------------------------

### readFile - Read File Content

Source: https://context7.com/symfony/filesystem/llms.txt

Reads and returns the entire contents of a file as a string.

```APIDOC
## readFile - Read File Content

### Description
Reads and returns the entire contents of a file as a string.

### Method
`readFile`

### Parameters
#### Path Parameters
- **path** (string) - Required - The path to the file to read.

### Request Example
```php
use Symfony\Component\Filesystem\Filesystem;

$filesystem = new Filesystem();
$content = $filesystem->readFile('/var/www/app/config/settings.json');
$settings = json_decode($content, true);

echo 'App name: ' . $settings['app_name'];
```

### Response
#### Success Response (200)
- **content** (string) - The entire content of the file as a string.
```

--------------------------------

### appendToFile - Append Content to File

Source: https://context7.com/symfony/filesystem/llms.txt

Appends content to an existing file, creating it if it doesn't exist. Supports file locking for concurrent access.

```APIDOC
## appendToFile - Append Content to File

### Description
Appends content to an existing file, creating it if it doesn't exist. Supports file locking.

### Method
`appendToFile`

### Parameters
#### Path Parameters
- **path** (string) - Required - The path to the file to append content to.
- **content** (string|resource) - Required - The content to append. Can be a string or a stream resource.
- **lock** (bool) - Optional - If true, acquires an exclusive lock on the file before writing. Defaults to false.

### Request Example
```php
use Symfony\Component\Filesystem\Filesystem;

$filesystem = new Filesystem();
$filesystem->appendToFile('/var/log/app.log', "[INFO] Application started\n");
$filesystem->appendToFile('/var/log/app.log', "[DEBUG] Processing request\n", true); // With file locking

$resource = fopen('php://memory', 'r+');
fwrite($resource, 'Additional content');
rewind($resource);
$filesystem->appendToFile('/path/to/file.txt', $resource);
fclose($resource);
```

### Response
This method does not return a value upon success. Exceptions are thrown on failure.
```

--------------------------------

### Path::hasExtension

Source: https://context7.com/symfony/filesystem/llms.txt

Checks if a path has a specific extension or any extension at all.

```APIDOC
## Path::hasExtension

### Description
Checks if a path has a specific extension or any extension at all.

### Parameters
#### Arguments
- **path** (string) - Required - The file path.
- **extension** (string|array) - Optional - The extension(s) to check.
- **caseInsensitive** (bool) - Optional - Whether the check should be case insensitive.
```

--------------------------------

### Check Path Type in PHP

Source: https://context7.com/symfony/filesystem/llms.txt

Determines if a path is absolute or relative, supporting various OS formats and stream wrappers.

```php
<?php
use Symfony\Component\Filesystem\Path;

Path::isAbsolute('/var/www/app');        // true
Path::isAbsolute('C:/Users/App');        // true (Windows)
Path::isAbsolute('phar:///app.phar');    // true (stream wrapper)
Path::isAbsolute('relative/path');       // false

Path::isRelative('relative/path');       // true
Path::isRelative('../parent/path');      // true
Path::isRelative('/var/www/app');        // false
```

--------------------------------

### Path::canonicalize

Source: https://context7.com/symfony/filesystem/llms.txt

Normalizes a path by resolving `.` and `..` segments and converting backslashes to forward slashes on Windows.

```APIDOC
## canonicalize - Normalize Path

### Description
Normalizes a path by resolving `.` and `..` segments and converting backslashes to forward slashes on Windows.

### Method
`Path::canonicalize`

### Parameters
#### Path Parameters
- **path** (string) - Required - The path to normalize.

### Request Example
```php
use Symfony\Component\Filesystem\Path;

$normalizedPath = Path::canonicalize('/var/www/../app/./config');
$normalizedHome = Path::canonicalize('~/projects/app');
$normalizedWindows = Path::canonicalize('C:\\Users\\App\\..\\Config');
```

### Response
#### Success Response (string)
- The normalized path.

#### Response Example
```
/var/www/config
/home/user/projects/app
C:/Users/Config
```
```

--------------------------------

### Path::getFilenameWithoutExtension

Source: https://context7.com/symfony/filesystem/llms.txt

Returns the filename without its extension.

```APIDOC
## Path::getFilenameWithoutExtension

### Description
Returns the filename without its extension.

### Parameters
#### Arguments
- **path** (string) - Required - The file path.
- **extension** (string) - Optional - Specific extension to remove.
```

--------------------------------

### Path::getDirectory

Source: https://context7.com/symfony/filesystem/llms.txt

Returns the directory portion of a path, handling edge cases that PHP's `dirname()` doesn't handle well.

```APIDOC
## getDirectory - Get Directory Part

### Description
Returns the directory portion of a path, handling edge cases that PHP's `dirname()` doesn't handle well.

### Method
`Path::getDirectory`

### Parameters
#### Path Parameters
- **path** (string) - Required - The path to get the directory from.

### Request Example
```php
use Symfony\Component\Filesystem\Path;

$directory1 = Path::getDirectory('/var/www/app/config.php');
$directory2 = Path::getDirectory('/var/www/app/');
$directory3 = Path::getDirectory('config.php');
$directory4 = Path::getDirectory('C:/symfony');
$directory5 = Path::getDirectory('/');
```

### Response
#### Success Response (string)
- The directory part of the path.

#### Response Example
```
/var/www/app
/var/www/app
(empty string)
C:/
/
```
```

--------------------------------

### Change File Permissions

Source: https://context7.com/symfony/filesystem/llms.txt

Modifies file or directory permissions, supporting recursive changes and umask application.

```php
<?php
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Filesystem\Exception\IOException;

$filesystem = new Filesystem();

try {
    // Set permissions to 0755 (rwxr-xr-x)
    $filesystem->chmod('/var/www/app/bin/console', 0o755);

    // Set permissions on multiple files
    $filesystem->chmod(['/path/script1.sh', '/path/script2.sh'], 0o755);

    // Apply permissions with umask
    $filesystem->chmod('/path/to/file', 0o777, 0o022); // Results in 0755

    // Recursive chmod on directory
    $filesystem->chmod('/var/www/app/var', 0o775, 0o000, true);
} catch (IOException $e) {
    echo 'Chmod failed: ' . $e->getMessage();
}
```

--------------------------------

### Check if Path is Local

Source: https://context7.com/symfony/filesystem/llms.txt

Use `Path::isLocal()` to determine if a given path refers to the local filesystem, excluding URLs with schemes.

```php
<?php
use Symfony\Component\Filesystem\Path;

Path::isLocal('/var/www/app');           // true
Path::isLocal('relative/path');          // true
Path::isLocal('C:/Users/App');           // true
Path::isLocal('phar:///app.phar');       // false
Path::isLocal('https://example.com');    // false
Path::isLocal('ftp://server/file');      // false
```

--------------------------------

### Path::isLocal

Source: https://context7.com/symfony/filesystem/llms.txt

Determines if a given path refers to the local filesystem by checking for the absence of a URL scheme.

```APIDOC
## Path::isLocal

### Description
Determines if a path refers to the local filesystem (no URL scheme).

### Parameters
#### Arguments
- **path** (string) - Required - The path to check.

### Response
- **boolean** - Returns true if the path is local, false otherwise.
```

--------------------------------

### Path::makeRelative

Source: https://context7.com/symfony/filesystem/llms.txt

Converts an absolute path to a relative path based on a given base path.

```APIDOC
## Path::makeRelative

### Description
Converts an absolute path to a relative path based on a given base path.

### Parameters
#### Arguments
- **path** (string) - Required - The path to convert.
- **basePath** (string) - Required - The base path to use.
```

--------------------------------

### Change File Extension in PHP

Source: https://context7.com/symfony/filesystem/llms.txt

Modifies the extension of a given file path.

```php
<?php
use Symfony\Component\Filesystem\Path;

echo Path::changeExtension('/var/www/app/config.yml', 'php');
// Output: /var/www/app/config.php

echo Path::changeExtension('/var/www/app/config.yml', '.json');
// Output: /var/www/app/config.json

echo Path::changeExtension('/var/www/app/README', 'md');
// Output: /var/www/app/README.md
```

--------------------------------

### readlink - Read Link Target

Source: https://context7.com/symfony/filesystem/llms.txt

Reads the target of a symbolic link. Optionally canonicalizes the path.

```APIDOC
## readlink - Read Link Target

### Description
Reads the target of a symbolic link. With the `canonicalize` option set to true, it returns the absolute resolved path.

### Method
`readlink`

### Parameters
#### Path Parameters
- **path** (string) - Required - The path to the symbolic link.
- **canonicalize** (bool) - Optional - If true, resolves all symbolic links to their absolute path. Defaults to false.

### Request Example
```php
use Symfony\Component\Filesystem\Filesystem;

$filesystem = new Filesystem();
$target = $filesystem->readlink('/var/www/app/public/assets'); // Returns: /var/www/shared/assets (or null)
$realPath = $filesystem->readlink('/var/www/app/public/assets', true); // Returns: /var/www/shared/assets (absolute resolved path, or null)
```

### Response
#### Success Response (200)
- **target** (string|null) - The target path of the symbolic link, or null if the path is not a symbolic link or does not exist.
```

--------------------------------

### Find Common Base Path in PHP

Source: https://context7.com/symfony/filesystem/llms.txt

Identifies the longest common directory path shared by multiple provided paths.

```php
<?php
use Symfony\Component\Filesystem\Path;

echo Path::getLongestCommonBasePath('/var/www/app/src', '/var/www/app/config');
// Output: /var/www/app

echo Path::getLongestCommonBasePath('/var/www/app', '/var/www/shared', '/var/log');
// Output: /var

echo Path::getLongestCommonBasePath('/var/www/app', '/home/user/app');
// Output: /

// Returns null for different Windows drives
echo Path::getLongestCommonBasePath('C:/Users/App', 'D:/Projects');
// Output: null
```