fraglet-entrypoint to support full replacements

Author: frison

entrypoint/cmd/main.go

@@ -153,6 +153,10 @@ func markerDisplay(inj fragletpkg.InjectionConfig) string {
 	if inj.MatchStart != "" && inj.MatchEnd != "" {
 		return fmt.Sprintf("`%s` ... `%s`", inj.MatchStart, inj.MatchEnd)
 	}
+	// Direct file replacement mode: codePath set without match markers
+	if inj.CodePath != "" {
+		return "entire file replacement (no marker)"
+	}
 	return "<no marker configured>"
 }
 
@@ -166,6 +170,22 @@ func normalizePath(path string) string {
 }
 
 func extractExampleCode(inj fragletpkg.InjectionConfig) string {
+	// Direct file replacement mode: return entire file content
+	if inj.CodePath != "" && inj.Match == "" && inj.MatchStart == "" {
+		data, err := os.ReadFile(inj.CodePath)
+		if err != nil {
+			// Return a simple placeholder if target file doesn't exist
+			return "echo 'Hello, World!'"
+		}
+		content := string(data)
+		// Trim trailing newlines
+		content = strings.TrimRight(content, "\n")
+		if content == "" {
+			return "echo 'Hello, World!'"
+		}
+		return content
+	}
+
 	// Read the target file to extract the code at the marker location
 	data, err := os.ReadFile(inj.CodePath)
 	if err != nil {

entrypoint/internal/fraglet/injector.go

@@ -1,6 +1,8 @@
 package fraglet
 
 import (
+	"fmt"
+	"io"
 	"os"
 
 	"github.com/ofthemachine/fraglet/pkg/fraglet"
@@ -15,11 +17,69 @@ func NewInjector() *Injector {
 
 // Inject performs fraglet injection using the file injector.
 // The injection config already contains the CodePath, so we just pass it through.
+// If codePath is set without match/match_start markers, performs direct file replacement.
 func (i *Injector) Inject(fragletPath string, injection fraglet.InjectionConfig) error {
+	// Detect direct file replacement mode: codePath set, no match markers
+	if injection.CodePath != "" && injection.Match == "" && injection.MatchStart == "" {
+		if err := copyFile(fragletPath, injection.CodePath); err != nil {
+			return fmt.Errorf("direct file replacement failed: %w", err)
+		}
+		// Remove temp fraglet file after copy
+		_ = os.Remove(fragletPath)
+		return nil
+	}
+
+	// Existing template injection logic
 	if err := fraglet.InjectFile(fragletPath, &injection); err != nil {
 		return err
 	}
 	// Remove temp fraglet file after injection
 	_ = os.Remove(fragletPath)
 	return nil
 }
+
+// copyFile copies the source file to the destination, preserving file permissions.
+func copyFile(src, dst string) error {
+	// Read source file
+	srcFile, err := os.Open(src)
+	if err != nil {
+		return fmt.Errorf("failed to open source file: %w", err)
+	}
+	defer srcFile.Close()
+
+	// Get source file info for permissions
+	srcInfo, err := srcFile.Stat()
+	if err != nil {
+		return fmt.Errorf("failed to stat source file: %w", err)
+	}
+
+	// Preserve destination file mode if it exists, otherwise use source mode
+	mode := srcInfo.Mode()
+	if dstInfo, err := os.Stat(dst); err == nil {
+		mode = dstInfo.Mode()
+	}
+
+	// Create destination file
+	dstFile, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, mode)
+	if err != nil {
+		return fmt.Errorf("failed to create destination file: %w", err)
+	}
+
+	// Copy contents
+	if _, err := io.Copy(dstFile, srcFile); err != nil {
+		dstFile.Close()
+		return fmt.Errorf("failed to copy file contents: %w", err)
+	}
+
+	// Close file before chmod to ensure data is flushed
+	if err := dstFile.Close(); err != nil {
+		return fmt.Errorf("failed to close destination file: %w", err)
+	}
+
+	// Ensure file permissions are set correctly after writing
+	if err := os.Chmod(dst, mode); err != nil {
+		return fmt.Errorf("failed to set file permissions: %w", err)
+	}
+
+	return nil
+}

entrypoint/releases/v0.3.0.md

@@ -0,0 +1,63 @@
+# Release v0.3.0
+
+## Key Highlights
+- **Direct file replacement**: fraglet-entrypoint can now overwrite an entire target file when `injection.codePath` is provided without match markers. Enables Brainfuck-style workflows where the program is the whole file.
+- **Smarter config parsing**: loader now distinguishes between line, range, and file injections instead of silently resetting `codePath`-only configs.
+- **Expanded test coverage**: integration suite exercises the file replacement path and new unit tests lock the injection-mode helpers.
+
+## ✨ New Features
+
+### Direct File Replacement (Brainfuck-ready)
+- Detects `codePath` without `match` / `match_start` / `match_end` and copies the fraglet payload directly over the destination file.
+- Runs as the container user, preserving permissions and honoring `execution.makeExecutable`.
+- Works seamlessly with existing `usage` / `guide` commands; usage now reports “entire file replacement” when no markers exist.
+
+### Injection Mode Helpers
+- Added `isLineInjection`, `isRangeInjection`, and `isFileInjection` helpers.
+- `isEmptyInjection` now only fires when *no* injection mode is configured, preventing accidental fallbacks to defaults.
+
+## 🔧 Configuration
+
+### File Replacement Example (`fraglet.yaml`)
+```yaml
+fragletTempPath: /FRAGLET
+injection:
+  codePath: /code/hello-world.bf   # no markers → entire file is replaced
+guide: /guide.md
+execution:
+  path: /code/hello-world.bf
+  makeExecutable: true
+```
+
+### Line / Range Modes (unchanged)
+- Still specify `match` for single-line replacement or `match_start` + `match_end` for regions.
+- You can mix in a custom `codePath` with either mode.
+
+## 🧪 Testing
+- `entrypoint/tests/docker_integration` now includes **Test 3** which mounts a shebang’d fraglet, replaces `/code/hello-world-replace.sh`, and proves execution works end-to-end.
+- Added `pkg/fraglet/config_test.go` to enforce the injection helper behavior.
+- `make test-entrypoint` and `go test ./pkg/fraglet/...` must be green before tagging.
+
+## 🚀 Building the Binary
+```bash
+cd entrypoint
+GOOS=linux GOARCH=amd64 go build -o dist/linux_amd64/fraglet-entrypoint ./cmd
+# Repeat for other arches as needed
+```
+
+## 🧩 Integrating with 100hellos/brainfuck
+1. Copy the new `fraglet-entrypoint` binary into the image (e.g. `/usr/local/bin/fraglet-entrypoint`).
+2. Add a `fraglet.yaml` like the file replacement example above.
+3. Set the container entrypoint to the binary:
+   ```dockerfile
+   COPY fraglet-entrypoint /usr/local/bin/fraglet-entrypoint
+   COPY fraglet-brainfuck.yaml /fraglet.yaml
+   ENTRYPOINT ["/usr/local/bin/fraglet-entrypoint"]
+   ```
+4. Build the image (tag `100hellos/brainfuck:local`) and test it via MCP:
+   ```bash
+   docker build -t 100hellos/brainfuck:local -f brainfuck/Dockerfile .
+   mcp run brainfuck '++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++.'
+   ```
+
+

entrypoint/tests/docker_integration/Dockerfile

@@ -9,8 +9,8 @@ COPY fraglet-entrypoint /usr/local/bin/fraglet-entrypoint
 # Copy all files from files/ directory to root
 COPY ./files /
 
-# Make the script executable
-RUN chmod +x /code/hello-world.sh
+# Make the scripts executable
+RUN chmod +x /code/hello-world.sh /code/hello-world-range.sh /code/hello-world-replace.sh
 
 # Set the entrypoint
 ENTRYPOINT ["/usr/local/bin/fraglet-entrypoint"]

entrypoint/tests/docker_integration/act.sh

@@ -4,8 +4,13 @@ set -e
 # Build the Docker image (binary is already in temp dir from harness)
 docker build -t fraglet-test:latest -f Dockerfile . > /dev/null 2>&1
 
-# Create a temporary fraglet file
+# Create temporary fraglet files
 echo 'echo "🎉 Fraglet injected successfully!"' > /tmp/test-fraglet.sh
+cat <<'EOF' > /tmp/test-fraglet-exec.sh
+#!/bin/sh
+echo "🎉 Fraglet injected successfully!"
+EOF
+chmod +x /tmp/test-fraglet-exec.sh
 
 # Test 1: Single match substitution (default config)
 echo "=== Test 1: Single match ==="
@@ -16,7 +21,15 @@ echo ""
 echo "=== Test 2: Range-based match ==="
 docker run --rm \
   -v /tmp/test-fraglet.sh:/FRAGLET:ro \
-  -e FRAGLET_CONFIG=/fraglet-alternative.yaml \
+  -e FRAGLET_CONFIG=/fraglet-range.yaml \
+  fraglet-test:latest 2>&1
+
+# Test 3: Direct file replacement (no match markers)
+echo ""
+echo "=== Test 3: Direct file replacement ==="
+docker run --rm \
+  -v /tmp/test-fraglet-exec.sh:/FRAGLET:ro \
+  -e FRAGLET_CONFIG=/fraglet-replacement.yaml \
   fraglet-test:latest 2>&1
 
 # Test the usage command
@@ -25,6 +38,11 @@ echo "---"
 echo "Testing usage:"
 docker run --rm fraglet-test:latest usage
 
+echo ""
+echo "---"
+echo "Testing usage (replacement config):"
+docker run --rm -e FRAGLET_CONFIG=/fraglet-replacement.yaml fraglet-test:latest usage
+
 echo ""
 echo "---"
 echo "Testing guide:"

entrypoint/tests/docker_integration/assert.txt

@@ -8,6 +8,9 @@ A
 🎉 Fraglet injected successfully!
 C
 
+=== Test 3: Direct file replacement ===
+🎉 Fraglet injected successfully!
+
 ---
 Testing usage:
 # Container Usage
@@ -44,6 +47,47 @@ docker run --rm -v /tmp/fraglet.sh:/FRAGLET:ro <container>
 
 ## Documentation
 
+- `usage` - Container usage (this document)
+- `guide` - Authoring guide for writing fraglets
+
+---
+Testing usage (replacement config):
+# Container Usage
+
+## Mount and Run
+
+Mount your fraglet code to /FRAGLET and run:
+
+```bash
+docker run --rm -v /path/to/fraglet:/FRAGLET:ro <container>
+```
+
+## Code Injection
+
+Code will be injected into `/code/hello-world-replace.sh` at the marker: entire file replacement (no marker)
+
+## Execution
+
+After injection, the container executes: `/code/hello-world-replace.sh`
+
+## Example
+
+Here's a functional example using the existing code:
+
+```bash
+# Read the existing code
+cat > /tmp/fraglet.sh << 'EOF'
+#!/bin/bash
+echo "This file will be completely replaced"
+echo "Original content here"
+EOF
+
+# Mount and run
+docker run --rm -v /tmp/fraglet.sh:/FRAGLET:ro <container>
+```
+
+## Documentation
+
 - `usage` - Container usage (this document)
 - `guide` - Authoring guide for writing fraglets
 ---

entrypoint/tests/docker_integration/files/code/hello-world-replace.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+echo "This file will be completely replaced"
+echo "Original content here"
+

…tegration/files/fraglet-alternative.yaml …ker_integration/files/fraglet-range.yamlentrypoint/tests/docker_integration/files/fraglet-alternative.yaml renamed to entrypoint/tests/docker_integration/files/fraglet-range.yaml entrypoint/tests/docker_integration/files/fraglet-alternative.yaml renamed to entrypoint/tests/docker_integration/files/fraglet-range.yaml

@@ -0,0 +1,8 @@
+fragletTempPath: /FRAGLET
+injection:
+  codePath: /code/hello-world-replace.sh
+guide: /guide.md
+execution:
+  path: /code/hello-world-replace.sh
+  makeExecutable: true
+

entrypoint/tests/docker_integration/files/fraglet-replacement.yaml

@@ -0,0 +1,5 @@
+name: brainfuck
+language: brainfuck
+container: 100hellos/brainfuck:local
+fragletPath: /FRAGLET
+