Truncated Code Begone

Notifications You must be signed in to change notification settings

Fork 0

Star 0

Releases: ue-patcher/ultimate_elastic_patcher

-->

Releases · ue-patcher/ultimate_elastic_patcher

The Ultimate Elastic Patcher v1.60

28 May 13:15

ue-patcher

v1.60

a1b3e49

This commit was created on GitHub.com and signed with GitHub’s verified signature.

Verified

Learn about vigilant mode.

Sorry, something went wrong.

Filter

Loading

Sorry, something went wrong.

Uh oh!

There was an error while loading. Please reload this page.

No results found

The Ultimate Elastic Patcher v1.60

Latest

Latest

Technical Manual & Operational Guide

1. Core Functional Features

The Ultimate Elastic Patcher operates as an event-driven system console that interacts with your file system and clipboard.

📋 Clipboard Monitoring

Trigger: F9 (Arm/Disarm)

Behavior: When armed, the system polls the clipboard. If valid patch patterns (such as Aider search/replace blocks, unified diffs, or code snippets) are detected, they are processed. Non-code text or trivial commands are ignored.

🎯 Tactical Alignment Mode

Trigger: Shift + F9 (Tactical Arm)

Behavior: Bypasses automatic placement decisions. For every clipboard transaction, it presents an interactive layout allowing you to manually route the patch, select targets, and shift code positions line-by-line.

🔒 State-Lock (Filelock)

Trigger: F8

Behavior: Locks the patcher to a single target file, skipping codebase-wide search routines. Useful when working with multiple files sharing similar method names.

📝 Integrated LLM Compose Workspace

Trigger: F7

Behavior: A built-in modal text editor replacing external dialog boxes to compose and format LLM requests.

Add File/Dir: Select and attach files/directories directly to the prompt.

Log Toggle: Attach console logs of failed patch runs to request corrections from the LLM.

Custom Instructions: Edit the custom instruction template appended to clipboard payloads.

Restore: Recalls the previous session's text and files in the event of an accidental close.

🗃️ Auditing & History Logging

Behavior: When CONF_AUDIT_LOG = True is set, all write operations are recorded:

Flat File Audit Log (ep_patch.log): Timestamps, target paths, actions, and unified diff previews.

JSON Transaction History (ep_history.json): Tracks exact pre- and post-patch states and backup references.

🔄 Session-Wide Undo & Redo

Trigger: Ctrl + Z / Ctrl + Y

Behavior: Non-destructive state engine. Undoing a patch restores the file to its pre-patch state and pushes the change to a forward-history (Redo) stack. Redoing retrieves files from the .redo/ directory.

🔍 Live Diff Viewer Integration

Trigger: F11

Behavior: Connects with the companion utility ep_diff_viewer.exe to display live side-by-side visual diffs, tracking files before and after modifications.

1. Technical Mechanics (How It Works)

2.1. Normalization & Sanity Scrubbing

[Raw Clipboard] ➔ [Purge Unicode Garbage] ➔ [Strip Citations & Line Numbers] ➔ [Heal Line-Wraps] ➔ [Extract Code Block]

Click to expand normalization stages

Garbage Character Purging: Converts non-breaking spaces (\xa0, \u202f), mathematical spaces, zero-width spaces (\u200b), byte order marks (\ufeff), and line separators (\u2028, \u2029) into standard spaces or deletes them.

Citation Block Removal: Strips web interface citation markers (e.g., [cite: 1], 【4†source】) to prevent syntax errors.

Line Number Deletion: Parses and removes copied line numbers (e.g., 12 | def my_func(): or 45: const x = 1).

Line-Wrap Healing: Merges lines that were wrapped mid-statement by web browsers (e.g., lines ending with an open quote followed by an indented line).

Text Extraction: Separates conversational text from code blocks using markdown backticks (```) or structural syntax keywords.

2.2. Language Lexing & Syntax Profiles

The patcher uses semantic language mapping to determine how blocks of code are structured. It classifies languages into three profiles:

Indent-Based Profiles (e.g., Python, Nim, GDScript): Uses visual indents to find scope boundaries. It handles decorators (lines starting with @) and docstrings without breaking the block.

Brace-Based Profiles (e.g., JavaScript, TypeScript, C++, Java, Rust, Go): Uses bracket-counting to find where classes and methods end, making it less dependent on indentation.

Keyword-Based Profiles (e.g., Ruby, Lua, Shell): Determines scope using keywords like end, then, or fi.

The Masking Pipeline

To prevent comments or strings from interfering with scope detection (such as a # inside a string, or a curly brace in a JS template literal), the engine masks these regions:

Raw Python line:

print("def fake_function():") # This is a comment containing }

Masked view in parser memory:

print(" ") #

Python Masking: Tracks single-line quotes, multiline triple quotes (""" and '''), and line comments. All text inside strings or comments is replaced with spaces in the parser's memory to avoid incorrect matches on class or function definitions.

Brace-Based Masking: Tracks block comments (/* ... */), inline comments (//), string literals, and template literals, masking them out before the bracket-matching engine evaluates scope depth.

2.3. The Fuzzy Sequence Matching Engine

When a candidate patch is parsed, the engine locates the target area in the file using a weighted similarity calculation:

1. Line Weight Calculation

Trivial lines (like else:, }, or return) are given low weights (1.0). Complex statements containing unique variables, assignments, or method calls are assigned higher weights:

$$\text{Weight} = 1.0 + \left( \frac{\text{Length of Normalized Line}}{30} \right)$$

This helps prevent common structural lines from causing false-positive matches.

1. Fuzzy Ratio Mapping & Gap Penalties

Each line in the file is compared against the normalized candidate line. If the engine has to skip lines in the target file to find a match, it applies a gap penalty:

$$\text{Adjusted Confidence} = \text{Base Match Score} - (\text{Skipped Lines} \times 0.15)$$

This penalty ensures that if a search block is matched across a widely dispersed set of lines, it is rejected unless an explicit truncation marker (ellipsis) is present.

1. Multi-Match Resolution

If multiple locations return identical high confidence scores:

For Structured Diffs (Unified or Aider patches), it clamps the match to the location closest to the expected line number to avoid duplicate modifications.

For Drop-In Patches, it applies the modification to all identical locations in reverse order (bottom-to-top) so that file line offsets stay correct.

2.4. Accordion Stitching (Handling Truncation)

If a patch contains placeholders like // ... rest of code or # existing logic, the Accordion Stitcher is activated to merge the new code with the old.

TARGET FILE BLOCK TRUNCATED LLM PATCH +--------------------+ +--------------------+ | def process(): | | def process(): | | init_env() | | # ... | | read_data() | =======> | update_val() | | write_data() | (Stitcher) | # ... | | clean_up() | +--------------------+ +--------------------+

Hole Detection: Scans for lines matching common truncation indicators (e.g., ..., ellipsis, existing logic, omitted).

Dominant Indentation Delta: Calculates the difference in indentation between the matching lines in the target file and the patch, using the most common difference to align the rest of the patch:

$$\Delta_{\text{indent}} = \text{Indent}{\text{patch}} - \text{Indent}{\text{file}}$$

Anchor Mapping: Matches the code before (Head Anchor) and after (Tail Anchor) the truncation marker to the target file's code.

Content Restoration: Replaces the truncation markers by pulling the original lines from the target file, adjusting their indentation by $\Delta_{\text{indent}}$ so they line up correctly.

Inline Truncation Cleanup: Parses, strips comment markers, and normalizes truncation markers written inline at the end of a line (such as import os # ...) to ensure clean syntax.

2.5. Safety, Formatting & Code Hygiene Pipelines

[Raw Patch] ➔ [Bracket Parity Check] ➔ [Tab/NBSP Scrub] ➔ [Dupe Resolution] ➔ [Import Hoisting] ➔ [Disk Write]

Bracket Parity Verification: Counts braces, brackets, and parentheses in the modified buffer, logging a console warning if a mismatch is found to help prevent compilation errors.

Duplicate Function Resolution: If a patch introduces a function that already exists in the same scope, the patcher identifies both versions, presents a side-by-side comparison in the console, and prompts you to select which version to keep.

Import Hoisting: Hoists imports written inline inside the new method bodies to the top of the file, keeping your import statements organized.

Vertical Spacing & Tab Normalization:

Converts hard tabs to 4 spaces (configurable).

Scrubs stray non-breaking spaces.

Compresses excessive blank lines (more than two consecutive empty lines).

Ensures a single blank line separates top-level classes and methods.

1. User Workflows & Operational Guides

3.1. Standard Mode Workflow (Copy-and-Apply)

The standard workflow is designed for quick, hands-off patching:

Launch the Patcher: Open elastic_patcher.exe. Ensure the console loads your project paths under "Monitoring folder(s)".

Arm the System: Press F9. The status line will change to ARMED - Now Monitoring Clipboard.

Generate the Patch: In your AI assistant, request a modification. Copy the resulting code block or diff output.

Automatic Processing: The patcher detects the copy event, normalizes the text, identifies the target file, applies the changes in memory, ru...

Read more