BACKUP=false

BACKUP_DIR="./.backups"

FILE_MARKER='^```[a-z]+ (.+)$'

SKIP_UNCHANGED=false

CONFIRM=false

ONLY_FILES=""

IGNORE_FILES=""

get_git_root() {

git rev-parse --show-toplevel 2>/dev/null

}

--backup) BACKUP=true; shift ;;

--backup-dir=*) BACKUP_DIR="${1#*=}"; shift ;;

--file-marker=*) FILE_MARKER="${1#*=}"; shift ;;

--skip-unchanged) SKIP_UNCHANGED=true; shift ;;

--confirm) CONFIRM=true; shift ;;

--only-files=*) ONLY_FILES="${1#*=}"; shift ;;

--ignore-files=*) IGNORE_FILES="${1#*=}"; shift ;;

echo " --dry-run Preview changes without applying them"

echo " --create-missing Create files that don't exist"

echo " --backup Create backup files before applying changes"

echo " --backup-dir=<dir> Directory for backups (default: ./.backups)"

echo " --file-marker=<regex> Regex to identify target files from markdown"

echo " --skip-unchanged Skip files with no changes"

echo " --verbose Show detailed output about changes"

echo " --confirm Prompt for confirmation before applying each change"

echo " --only-files=<pattern> Only apply changes to files matching pattern"

echo " --ignore-files=<pattern> Ignore changes for files matching pattern"

echo " --help, -h Show this help message"

GIT_ROOT=$(get_git_root)

if [ -z "$GIT_ROOT" ] && [ "$VERBOSE" = true ]; then

echo "Warning: Not in a git repository, absolute paths will be treated as system paths"

if [ "$BACKUP" = true ] && [ ! -d "$BACKUP_DIR" ]; then

if [ "$DRY_RUN" = false ]; then

mkdir -p "$BACKUP_DIR"

elif [ "$VERBOSE" = true ]; then

echo "[DRY RUN] Would create backup directory: $BACKUP_DIR"

fi

BLOCKS_FILE="$TEMP_DIR/blocks.txt"

normalize_path() {

local path="$1"

if [ -n "$GIT_ROOT" ] && [[ "$path" == /* ]]; then

# Remove leading slash and resolve relative to git root

local rel_path="${path#/}"

echo "$GIT_ROOT/$rel_path"

else

echo "$path"

fi

}

normalized_file=$(normalize_path "$current_file")

echo "Starting code block for file: $current_file (normalized: $normalized_file)"

current_file_formatted=$(echo "$current_file" | sed 's/^\.\///')

echo "Completed code block for file: $current_file_formatted"

local skipped=false

if [ -n "$IGNORE_FILES" ] && [[ "$file" == $IGNORE_FILES ]]; then

if [ "$VERBOSE" = true ]; then

echo "Skipping ignored file: $file"

fi

return

fi

if [ -n "$ONLY_FILES" ] && [[ "$file" != $ONLY_FILES ]]; then

if [ "$VERBOSE" = true ]; then

echo "Skipping file not matching include pattern: $file"

fi

return

fi

# Normalize file path

local normalized_file=$(normalize_path "$file")

file="$normalized_file"

elif [ "$VERBOSE" = true ]; then

echo "[DRY RUN] Would create file: $file"

echo "---"

cat "$content_file"

echo "---"

if [ "$SKIP_UNCHANGED" = true ]; then

diff -q "$file" "$content_file" > /dev/null

if [ $? -eq 0 ]; then

if [ "$VERBOSE" = true ]; then

echo "Skipping unchanged file: $file"

fi

skipped=true

if [ "$skipped" = false ]; then

local changes=$(diff -u "$file" "$content_file")

if [ -z "$changes" ]; then

if [ "$VERBOSE" = true ]; then

echo "No changes needed for: $file"

fi

return

fi

if [ "$VERBOSE" = true ]; then

echo "Changes for $file:"

echo "$changes"

echo ""

else

echo "Modifying: $file"

fi

if [ "$CONFIRM" = true ]; then

read -p "Apply changes to $file? (y/n) " -n 1 -r

echo

if [[ ! $REPLY =~ ^[Yy]$ ]]; then

echo "Skipping file: $file"

return

fi

fi

if [ "$BACKUP" = true ]; then

local backup_file="$BACKUP_DIR/$(basename "$file").$(date +%Y%m%d%H%M%S).bak"

if [ "$DRY_RUN" = false ]; then

mkdir -p "$(dirname "$backup_file")"

cp "$file" "$backup_file"

if [ "$VERBOSE" = true ]; then

echo "Created backup: $backup_file"

fi

elif [ "$VERBOSE" = true ]; then

echo "[DRY RUN] Would create backup: $backup_file"

fi

fi

if [ "$DRY_RUN" = false ]; then

cat "$content_file" > "$file"

echo "Updated file: $file"

else

echo "[DRY RUN] Would update file: $file"

fi

if [ -n "$GIT_ROOT" ]; then

echo "Git repository root detected at: $GIT_ROOT"

fi

The `apply-md` tool extracts code blocks from markdown (typically LLM responses) and applies them to your filesystem. It supports both relative and absolute paths, with absolute paths resolved relative to the git repository root when run within a git repository.

| `--backup` | Create backup files before applying changes | False |

| `--backup-dir=<dir>` | Directory for backups | "./.backups" |

| `--file-marker=<regex>` | Regex to identify target files from markdown | "```[a-z]+ (.+)" |

| `--skip-unchanged` | Skip files with no changes | False |

| `--verbose` | Show detailed output about changes, including git root detection | False |

| `--confirm` | Prompt for confirmation before applying each change | False |

| `--only-files=<pattern>` | Only apply changes to files matching pattern | None |

| `--ignore-files=<pattern>` | Ignore changes for files matching pattern | None |

2. If run within a git repository, it detects the repository root

3. It looks for code blocks that specify a filename (e.g., ```javascript src/utils.js or ```bash /apply-md)

4. Absolute paths (starting with /) are resolved relative to the git root when applicable

5. It extracts the code from these blocks

6. It applies the code to the corresponding files in your filesystem

Make backups before applying changes:

cat llm_response.md | ./apply-md --backup

Only apply changes to specific files:

cat llm_response.md | ./apply-md --only-files="*.js"

Apply changes using absolute paths relative to git root:

echo -e "```bash /scripts/test.sh\necho 'test'\n```" | ./apply-md --create-missing

The script expects code blocks in these formats:

```bash /scripts/deploy.sh

#!/bin/bash

echo "Deploying..."

```

The language specification is optional, but the filename is required. Absolute paths (starting with /) will be resolved relative to the git repository root when run within a git repository.

- Use `--verbose` to see the detected git root and normalized paths

- Consider using `--backup` for important changes

- Use `--confirm` to review each change individually

- When using absolute paths, ensure you're running from within a git repository

- If not in a git repository, absolute paths will be treated as system paths

When run within a git repository:

- Detects the repository root automatically

- Converts absolute paths (e.g., `/src/main.js`) to relative paths from the git root

- Shows the detected git root in verbose mode

If not in a git repository:

- Absolute paths are treated as system absolute paths

- A warning is shown in verbose mode