Merge pull request #2 from neongreen/copilot/fix-bb410bf8-6466-4605-a8ad-925fdd32e456

Add GitHub Actions workflow, default in-place formatting, --check flag, abbreviation handling, and integration documentation for markdown-format

Author: neongreen

.github/workflows/markdown-format.yml

@@ -0,0 +1,26 @@
+name: markdown-format
+
+on:
+  push:
+    paths:
+      - 'markdown-format/**'
+  pull_request:
+    paths:
+      - 'markdown-format/**'
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.24.7'
+      
+      - name: Run tests
+        working-directory: markdown-format
+        run: go test -v

markdown-format/README.md

@@ -23,22 +23,51 @@ Formatting markdown with one sentence per line makes it easier to:
 
 ## Installation
 
+### With Go
+
 ```bash
 go build
 ```
 
+### With mise
+
+Install using [mise](https://mise.jdx.dev/) with the Go backend:
+
+```bash
+mise use -g go:github.com/neongreen/mono/markdown-format@main
+```
+
+Or add to your `.mise.toml`:
+
+```toml
+[tools]
+"go:github.com/neongreen/mono/markdown-format" = "main"
+```
+
 ## Usage
 
-Format a markdown file:
+Format files in place (default behavior):
 
 ```bash
-./markdown-format input.md > output.md
+./markdown-format file1.md file2.md file3.md
 ```
 
-Read from stdin:
+Check if files are formatted without modifying them:
 
 ```bash
-cat input.md | ./markdown-format - > output.md
+./markdown-format --check file1.md file2.md
+```
+
+Format from stdin to stdout:
+
+```bash
+cat input.md | ./markdown-format
+```
+
+Or:
+
+```bash
+./markdown-format < input.md > output.md
 ```
 
 ## Example
@@ -59,6 +88,62 @@ It has multiple sentences.
 Let's format it!
 ```
 
+## Integration with Formatting Tools
+
+See the [examples/](examples/) directory for complete configuration files and sample markdown files demonstrating the integrations.
+
+### treefmt
+
+[treefmt](https://github.com/numtide/treefmt) is a universal code formatter that runs multiple formatters with one command.
+
+Add to your `treefmt.toml`:
+
+```toml
+[formatter.markdown-format]
+command = "markdown-format"
+includes = ["*.md"]
+```
+
+Then run:
+
+```bash
+treefmt
+```
+
+### dprint
+
+[dprint](https://dprint.dev/) is a pluggable and configurable code formatter.
+
+To integrate markdown-format with dprint, use the exec plugin. First, install the exec plugin if you haven't already:
+
+```bash
+dprint config add exec
+```
+
+Then add to your `dprint.json`:
+
+```json
+{
+  "exec": {
+    "commands": [{
+      "command": "markdown-format",
+      "exts": ["md"]
+    }]
+  },
+  "plugins": [
+    "https://plugins.dprint.dev/exec-0.5.0.json@<hash>"
+  ]
+}
+```
+
+The exec plugin will handle passing files to markdown-format for in-place formatting.
+
+Run dprint:
+
+```bash
+dprint fmt
+```
+
 ## License
 
 MIT License - See LICENSE file in the repository root.

markdown-format/examples/README.md

@@ -0,0 +1,37 @@
+# Integration Examples
+
+This directory contains example configurations and files for integrating markdown-format with various formatting tools.
+
+## Files
+
+- `treefmt.toml` - Example configuration for treefmt
+- `dprint.json` - Example configuration for dprint
+- `sample-input.md` - Sample markdown file before formatting
+- `sample-output.md` - Sample markdown file after formatting with markdown-format
+
+## Testing the Integration
+
+### With treefmt
+
+1. Install treefmt (https://github.com/numtide/treefmt)
+2. Copy `treefmt.toml` to your project root
+3. Ensure `markdown-format` is in your PATH or update the `command` in `treefmt.toml`
+4. Run `treefmt` to format all markdown files
+
+### With dprint
+
+1. Install dprint (https://dprint.dev/)
+2. Add the exec plugin: `dprint config add exec`
+3. Copy `dprint.json` to your project root (or merge the configuration)
+4. Ensure `markdown-format` is in your PATH or update the `command` in the exec configuration
+5. Run `dprint fmt` to format all markdown files
+
+## Verifying the Integration
+
+You can test the integration by:
+
+1. Creating a copy of `sample-input.md` in your project
+2. Running your formatter (treefmt or dprint)
+3. Comparing the result with `sample-output.md`
+
+The output should match, with one sentence per line while preserving all markdown structure.

markdown-format/examples/dprint.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://dprint.dev/schemas/v0.json",
+  "exec": {
+    "commands": [{
+      "command": "markdown-format",
+      "exts": ["md"]
+    }]
+  },
+  "plugins": [
+    "https://plugins.dprint.dev/exec-0.5.0.json@<hash>"
+  ],
+  "excludes": [
+    "**/*-lock.json",
+    "**/node_modules",
+    "**/.git"
+  ]
+}

markdown-format/examples/sample-input.md

@@ -0,0 +1,21 @@
+# Sample Document
+
+This is a paragraph with multiple sentences. It should be formatted with one sentence per line. This makes git diffs easier to read.
+
+## Features
+
+- First item with a long description. This has multiple sentences.
+- Second item with nested content:
+  - Nested item one
+  - Nested item two with more details
+- Third item with more text. And even more!
+- Items can use abbreviations, e.g. this one. They should be handled correctly.
+
+## Code Example
+
+```python
+def hello():
+    print("Hello, world!")
+```
+
+Conclusion paragraph. Final thoughts here. That's all!

markdown-format/examples/sample-output.md

@@ -0,0 +1,27 @@
+# Sample Document
+
+This is a paragraph with multiple sentences.
+It should be formatted with one sentence per line.
+This makes git diffs easier to read.
+
+## Features
+
+- First item with a long description.
+  This has multiple sentences.
+- Second item with nested content:- Nested item one
+- Nested item two with more details
+- Third item with more text.
+  And even more!
+- Items can use abbreviations, e.g. this one.
+  They should be handled correctly.
+
+## Code Example
+
+```python
+def hello():
+    print("Hello, world!")
+```
+
+Conclusion paragraph.
+Final thoughts here.
+That's all!

markdown-format/examples/treefmt.toml

@@ -0,0 +1,8 @@
+# Example treefmt configuration for markdown-format
+# Place this file in your project root as treefmt.toml
+
+[formatter.markdown-format]
+command = "markdown-format"
+options = []
+includes = ["*.md"]
+excludes = []

markdown-format/main.go

@@ -14,8 +14,11 @@ import (
 	"github.com/yuin/goldmark/text"
 )
 
-// sentenceBoundaryRegex matches sentence boundaries (. ! ?) followed by space or end of string
-var sentenceBoundaryRegex = regexp.MustCompile(`([.!?])(\s+)`)
+// Common abbreviations that should not be treated as sentence boundaries
+var commonAbbreviations = []string{"e.g.", "i.e.", "etc.", "vs.", "cf.", "ex.", "viz.", "approx.", "ca."}
+
+// sentenceBoundaryRegex matches sentence boundaries (. ! ?) followed by space and uppercase letter
+var sentenceBoundaryRegex = regexp.MustCompile(`([.!?])(\s+)([A-Z])`)
 
 // formatMarkdown formats markdown content with one sentence per line
 func formatMarkdown(input []byte) ([]byte, error) {
@@ -294,16 +297,29 @@ func collectInlineText(node ast.Node, source []byte, buf *bytes.Buffer) error {
 
 // splitIntoSentences splits text into sentences
 func splitIntoSentences(text string) []string {
+	// Protect common abbreviations by replacing them temporarily
+	protected := text
+	replacements := make(map[string]string)
+	for i, abbr := range commonAbbreviations {
+		placeholder := fmt.Sprintf("\x00ABBR%d\x00", i)
+		replacements[placeholder] = abbr
+		protected = strings.ReplaceAll(protected, abbr, placeholder)
+	}
+	
 	// Replace sentence boundaries with a special marker
-	text = sentenceBoundaryRegex.ReplaceAllString(text, "$1\n\n")
+	protected = sentenceBoundaryRegex.ReplaceAllString(protected, "$1\n\n$3")
 
 	// Split by the marker
-	parts := strings.Split(text, "\n\n")
+	parts := strings.Split(protected, "\n\n")
 
 	var sentences []string
 	for _, part := range parts {
 		part = strings.TrimSpace(part)
 		if part != "" {
+			// Restore abbreviations
+			for placeholder, abbr := range replacements {
+				part = strings.ReplaceAll(part, placeholder, abbr)
+			}
 			sentences = append(sentences, part)
 		}
 	}
@@ -312,39 +328,58 @@ func splitIntoSentences(text string) []string {
 }
 
 func main() {
+	checkFlag := flag.Bool("check", false, "check if files are formatted without modifying them")
 	flag.Parse()
 
 	args := flag.Args()
+	
+	// If no arguments, read from stdin and write to stdout
 	if len(args) == 0 {
-		fmt.Fprintln(os.Stderr, "Usage: markdown-format <file>")
-		fmt.Fprintln(os.Stderr, "       or pipe input via stdin")
-		os.Exit(1)
-	}
-
-	var input []byte
-	var err error
-
-	if args[0] == "-" {
-		// Read from stdin
-		input, err = io.ReadAll(os.Stdin)
+		input, err := io.ReadAll(os.Stdin)
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "Error reading stdin: %v\n", err)
 			os.Exit(1)
 		}
-	} else {
-		// Read from file
-		input, err = os.ReadFile(args[0])
+		output, err := formatMarkdown(input)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error reading file: %v\n", err)
+			fmt.Fprintf(os.Stderr, "Error formatting markdown: %v\n", err)
 			os.Exit(1)
 		}
+		fmt.Print(string(output))
+		return
 	}
 
-	output, err := formatMarkdown(input)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error formatting markdown: %v\n", err)
+	// Handle file(s) - in-place by default
+	hasErrors := false
+	for _, filename := range args {
+		input, err := os.ReadFile(filename)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error reading file %s: %v\n", filename, err)
+			os.Exit(1)
+		}
+		output, err := formatMarkdown(input)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error formatting %s: %v\n", filename, err)
+			os.Exit(1)
+		}
+		
+		if *checkFlag {
+			// Check mode: compare without modifying
+			if !bytes.Equal(input, output) {
+				fmt.Fprintf(os.Stderr, "%s: not formatted\n", filename)
+				hasErrors = true
+			}
+		} else {
+			// Default: write in-place
+			err = os.WriteFile(filename, output, 0644)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Error writing file %s: %v\n", filename, err)
+				os.Exit(1)
+			}
+		}
+	}
+	
+	if hasErrors {
 		os.Exit(1)
 	}
-
-	fmt.Print(string(output))
 }