fix-smart-quotes 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Johannes Kleske
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,81 @@
+# fix-smart-quotes
+
+Convert straight quotes to proper typographic ("smart") quotes in Markdown files.
+
+| Language | Before | After |
+|----------|--------|-------|
+| German | `"text"` | `„text"` (U+201E / U+201C) |
+| English | `"text"` | `"text"` (U+201C / U+201D) |
+
+## Why?
+
+When AI coding assistants edit Markdown files, they often replace typographic quotes with straight quotes. This is intentional—straight quotes are safer for code and avoid encoding issues.
+
+But for prose text, proper typography matters.
+
+**Example - before AI edit:**
+```
+Sie sagte: „Das ist wichtig."
+```
+
+**After AI edit:**
+```
+Sie sagte: "Das ist wichtig."
+```
+
+This tool restores the correct quotes—either manually via CLI, or automatically after each Claude Code edit via hook.
+
+## Installation
+
+```bash
+npm install -g fix-smart-quotes
+```
+
+Or use directly without installing:
+
+```bash
+npx fix-smart-quotes file.md
+```
+
+## CLI Usage
+
+```bash
+# Single file
+fix-smart-quotes README.md
+
+# Multiple files (shell expands glob)
+fix-smart-quotes docs/*.md
+```
+
+## Claude Code Hook
+
+The primary use case: automatically fix quotes in files that Claude Code just edited. The hook runs **only** on files modified by Claude's Write or Edit tools—not on your entire project.
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "PostToolUse": [{
+      "matcher": "Write|Edit",
+      "hooks": [{
+        "type": "command",
+        "command": "npx fix-smart-quotes \"$FILE_PATH\"",
+        "timeout": 30
+      }]
+    }]
+  }
+}
+```
+
+This means: After Claude writes or edits a file, immediately run the quote fixer on that specific file.
+
+## Features
+
+- **Auto-detects language** via `lang:` frontmatter or content heuristics
+- **Protects technical syntax:** code blocks, inline code, HTML attributes, Liquid/Jekyll templates, Kramdown attributes, Markdown links
+- **Zero dependencies**
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+
+// === LANGUAGE DETECTION ===
+
+const GERMAN_MARKERS = new Set([
+  "und", "der", "die", "das", "ist", "für", "mit", "auf", "ein", "eine",
+  "nicht", "sich", "auch", "dass", "werden", "sein", "haben", "können",
+  "mehr", "oder", "wenn", "aber", "wird", "sind", "wurde", "durch",
+  "bei", "nach", "vom", "zum", "zur", "aus", "wie", "kann", "noch",
+  "nur", "über", "diese", "dieser", "dieses", "einem", "einen", "einer"
+]);
+
+const ENGLISH_MARKERS = new Set([
+  "the", "and", "is", "of", "to", "in", "that", "for", "with", "this",
+  "from", "are", "have", "was", "been", "will", "would", "could", "should",
+  "which", "their", "there", "about", "into", "what", "when", "where",
+  "can", "has", "had", "but", "not", "you", "all", "were", "they", "be",
+  "how", "than", "then", "some", "these", "those", "such", "only", "also"
+]);
+
+// Quote characters by language
+const QUOTES = {
+  de: {
+    openDouble: "\u201E",   // „
+    closeDouble: "\u201C",  // "
+    openSingle: "\u201A",   // ‚
+    closeSingle: "\u2018"   // '
+  },
+  en: {
+    openDouble: "\u201C",   // "
+    closeDouble: "\u201D",  // "
+    openSingle: "\u2018",   // '
+    closeSingle: "\u2019"   // '
+  }
+};
+
+// Check frontmatter for lang: field
+function getLanguageFromFrontmatter(text) {
+  const frontmatterMatch = text.match(/^---\n([\s\S]*?)\n---/);
+  if (frontmatterMatch) {
+    const langMatch = frontmatterMatch[1].match(/^lang:\s*(de|en)\s*$/m);
+    if (langMatch) {
+      return langMatch[1];
+    }
+  }
+  return null;
+}
+
+// Language detection via word frequency heuristics
+function detectLanguageFromContent(text) {
+  const words = text.toLowerCase().match(/\b[a-zäöüß]+\b/g) || [];
+  let germanScore = 0;
+  let englishScore = 0;
+
+  for (const word of words) {
+    if (GERMAN_MARKERS.has(word)) germanScore++;
+    if (ENGLISH_MARKERS.has(word)) englishScore++;
+  }
+
+  // Default to German on tie or insufficient data
+  return englishScore > germanScore ? "en" : "de";
+}
+
+// Main language detection function
+function detectLanguage(text) {
+  // Priority 1: Frontmatter
+  const frontmatterLang = getLanguageFromFrontmatter(text);
+  if (frontmatterLang) {
+    return frontmatterLang;
+  }
+
+  // Priority 2: Content analysis
+  return detectLanguageFromContent(text);
+}
+
+// === INLINE PROTECTION PATTERNS ===
+// These patterns protect technical areas within lines
+
+// Liquid Tags: {% ... %}
+const LIQUID_TAG_PATTERN = /\{%[\s\S]*?%\}/g;
+
+// Liquid Output: {{ ... }}
+const LIQUID_OUTPUT_PATTERN = /\{\{[\s\S]*?\}\}/g;
+
+// Kramdown attributes (Jekyll): {: .class} or {: title="..."}
+// IMPORTANT: Must come BEFORE HTML_ATTR!
+const KRAMDOWN_ATTR_PATTERN = /\{:[^}]*\}/g;
+
+// HTML attributes: href="...", style='...', class="...", data-foo="...", etc.
+const HTML_ATTR_PATTERN = /\b([a-z][a-z0-9-]*)\s*=\s*(["'])((?:(?!\2)[^\\]|\\.)*)(\2)/gi;
+
+// Markdown links: [text](url) and [text](url "title")
+// Match entire construct to protect URLs and titles with any quote mix
+const MD_LINK_PATTERN = /\[([^\]]*)\]\([^)]+\)/g;
+
+// Inline code: `...`
+const INLINE_CODE_PATTERN = /`[^`]+`/g;
+
+// === PROTECT/RESTORE SYSTEM ===
+
+// Placeholder markers (no null bytes as they cause issues)
+const PROTECT_START = "__PROT_";
+const PROTECT_END = "_TORP__";
+
+function createProtector() {
+  const segments = [];
+
+  function protect(text, pattern) {
+    return text.replace(pattern, (match) => {
+      const index = segments.length;
+      segments.push(match);
+      return `${PROTECT_START}${index}${PROTECT_END}`;
+    });
+  }
+
+  function restore(text) {
+    const pattern = new RegExp(`${PROTECT_START}(\\d+)${PROTECT_END}`, "g");
+    let result = text;
+    let prevResult;
+    // Repeat until no placeholders remain (for nested protected patterns)
+    do {
+      prevResult = result;
+      result = result.replace(pattern, (_, index) => {
+        return segments[parseInt(index, 10)];
+      });
+    } while (result !== prevResult);
+    return result;
+  }
+
+  function reset() {
+    segments.length = 0;
+  }
+
+  return { protect, restore, reset };
+}
+
+// Helper: Is this character a letter?
+function isLetter(char) {
+  return /[a-zA-ZäöüßÄÖÜ]/.test(char);
+}
+
+// Normalize typographic quotes to straight quotes
+function normalizeQuotes(text) {
+  return text
+    // Double quotes → straight "
+    .replace(/[\u201C\u201D\u201E\u201F\u00AB\u00BB]/g, '"')
+    // Single quotes → straight '
+    .replace(/[\u2018\u2019\u201A\u201B]/g, "'");
+}
+
+// Replace quotes in text, updating toggle state
+function replaceQuotesInText(text, state, quotes) {
+  const normalizedText = normalizeQuotes(text);
+  let processed = "";
+
+  for (let k = 0; k < normalizedText.length; k++) {
+    const currentChar = normalizedText[k];
+    const prevChar = k > 0 ? normalizedText[k - 1] : "";
+    const nextChar = k < normalizedText.length - 1 ? normalizedText[k + 1] : "";
+
+    if (currentChar === '"') {
+      // Straight double quote
+      if (state.doubleQuoteOpen) {
+        processed += quotes.openDouble;
+      } else {
+        processed += quotes.closeDouble;
+      }
+      state.doubleQuoteOpen = !state.doubleQuoteOpen;
+    } else if (currentChar === "'") {
+      // Straight single quote - ignore apostrophes within words
+      const isApostrophe = isLetter(prevChar) && isLetter(nextChar);
+
+      if (isApostrophe) {
+        // Keep apostrophes unchanged (e.g., "it's", "We've")
+        processed += currentChar;
+      } else {
+        // Replace as quote
+        if (state.singleQuoteOpen) {
+          processed += quotes.openSingle;
+        } else {
+          processed += quotes.closeSingle;
+        }
+        state.singleQuoteOpen = !state.singleQuoteOpen;
+      }
+    } else {
+      processed += currentChar;
+    }
+  }
+  return processed;
+}
+
+// Process a single file
+function processFile(filePath) {
+  const content = fs.readFileSync(filePath, "utf8");
+  const lines = content.split("\n");
+  const protectedRanges = [];
+
+  // Detect YAML frontmatter (only at file start)
+  let inFrontmatter = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (i === 0 && lines[i].trim() === "---") {
+      inFrontmatter = true;
+      protectedRanges.push({ start: i, end: -1, type: "frontmatter" });
+    } else if (inFrontmatter && lines[i].trim() === "---") {
+      protectedRanges[protectedRanges.length - 1].end = i;
+      inFrontmatter = false;
+      break;
+    }
+  }
+
+  // Detect code blocks
+  let inCodeBlock = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim().startsWith("```")) {
+      if (!inCodeBlock) {
+        protectedRanges.push({ start: i, end: -1, type: "codeblock" });
+        inCodeBlock = true;
+      } else {
+        protectedRanges[protectedRanges.length - 1].end = i;
+        inCodeBlock = false;
+      }
+    }
+  }
+
+  // Check if line is fully protected
+  function isProtectedLine(lineIndex) {
+    return protectedRanges.some(
+      (range) => lineIndex >= range.start && lineIndex <= range.end
+    );
+  }
+
+  // Detect language
+  const lang = detectLanguage(content);
+  const quotes = QUOTES[lang];
+
+  // Create protector instance
+  const protector = createProtector();
+
+  // Initialize quote state OUTSIDE processLine so it persists across lines
+  const state = { doubleQuoteOpen: true, singleQuoteOpen: true };
+
+  // Process line with protect → replace → restore
+  function processLine(line) {
+    protector.reset();
+
+    // PROTECT: Order matters!
+    let processed = protector.protect(line, INLINE_CODE_PATTERN);
+    processed = protector.protect(processed, LIQUID_TAG_PATTERN);
+    processed = protector.protect(processed, LIQUID_OUTPUT_PATTERN);
+    processed = protector.protect(processed, KRAMDOWN_ATTR_PATTERN);
+    processed = protector.protect(processed, HTML_ATTR_PATTERN);
+    processed = protector.protect(processed, MD_LINK_PATTERN);
+
+    // REPLACE: Replace quotes using shared state (persists across lines)
+    processed = replaceQuotesInText(processed, state, quotes);
+
+    // RESTORE: Restore protected areas
+    processed = protector.restore(processed);
+
+    return processed;
+  }
+
+  // Process all lines
+  const resultLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (isProtectedLine(i)) {
+      resultLines.push(lines[i]);
+      continue;
+    }
+    resultLines.push(processLine(lines[i]));
+  }
+
+  fs.writeFileSync(filePath, resultLines.join("\n"), "utf8");
+  const langLabel = lang === "de" ? "German" : "English";
+  console.log(`\u2713 Fixed quotes (${langLabel}): ${filePath}`);
+}
+
+// === MAIN ===
+
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.error("Usage: fix-smart-quotes <file.md> [file2.md ...]");
+    process.exit(1);
+  }
+
+  let hasErrors = false;
+
+  for (const arg of args) {
+    try {
+      if (!fs.existsSync(arg)) {
+        console.error(`Error: File not found: ${arg}`);
+        hasErrors = true;
+        continue;
+      }
+      processFile(arg);
+    } catch (err) {
+      console.error(`Error processing ${arg}: ${err.message}`);
+      hasErrors = true;
+    }
+  }
+
+  process.exit(hasErrors ? 1 : 0);
+}
+
+main();

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "fix-smart-quotes",
+  "version": "1.0.0",
+  "description": "Fix straight quotes to smart quotes in Markdown (DE/EN)",
+  "main": "index.js",
+  "bin": {
+    "fix-smart-quotes": "./index.js"
+  },
+  "scripts": {
+    "test": "node test/test.js"
+  },
+  "keywords": [
+    "markdown",
+    "typography",
+    "quotes",
+    "smart-quotes",
+    "german",
+    "english",
+    "claude-code"
+  ],
+  "author": "Johannes Kleske",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jkleske/fix-smart-quotes"
+  },
+  "engines": {
+    "node": ">=14"
+  }
+}

package/test/fixtures/english.md

@@ -0,0 +1,8 @@
+---
+title: Test
+lang: en
+---
+
+This is a "test" with 'quotes'.
+
+She said: "Hello World" and left.

package/test/fixtures/german.md

@@ -0,0 +1,8 @@
+---
+title: Test
+lang: de
+---
+
+Das ist ein "Test" mit 'Anführungszeichen'.
+
+Er sagte: "Hallo Welt" und ging.

package/test/fixtures/protected.md

@@ -0,0 +1,14 @@
+---
+title: "Test Document"
+lang: de
+---
+
+Normal "text" here.
+
+<a href="https://example.com" style="color: red;">Link</a>
+
+{{ variable | date: "%Y-%m-%d" }}
+
+{: .class title="tooltip"}
+
+Der Befehl `echo "test"` funktioniert.

package/test/test-markdown-links.md

@@ -0,0 +1,32 @@
+---
+lang: en
+---
+
+# Markdown Link Title Protection Test
+
+## Test Case 1: Link with double-quoted title
+[test](https://example.com "title")
+
+## Test Case 2: Link with single-quoted title
+[test](https://example.com 'title')
+
+## Test Case 3: Link with double-quoted title containing single quotes
+[test](https://example.com "title with 'quotes'")
+
+## Test Case 4: Link with single-quoted title containing double quotes
+[test](https://example.com 'title with "quotes"')
+
+## Test Case 5: Link without title
+[test](https://example.com)
+
+## Test Case 6: Multiple links on same line
+Here are [link1](https://example.com "first title") and [link2](https://example.com 'second title') together.
+
+## Test Case 7: Complex nested quotes in title
+[complex](https://example.com "He said 'Hello' and she replied")
+
+## Test Case 8: Regular quotes OUTSIDE links should still be converted
+This is “text with quotes” that should be converted to smart quotes.
+
+## Test Case 9: Mixed - link protection + normal conversion
+This “sentence” has [a link](https://example.com "with a title") and “more quotes” to convert.

package/test/test.js

@@ -0,0 +1,94 @@
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const FIXTURES_DIR = path.join(__dirname, "fixtures");
+const CLI = path.join(__dirname, "..", "index.js");
+
+// Test helper: copy fixture, run CLI, check result, cleanup
+function testFile(fixtureName, expectedPatterns, unexpectedPatterns = []) {
+  const fixture = path.join(FIXTURES_DIR, fixtureName);
+  const temp = path.join(FIXTURES_DIR, `_temp_${fixtureName}`);
+
+  // Copy fixture to temp
+  fs.copyFileSync(fixture, temp);
+
+  try {
+    // Run CLI
+    execSync(`node "${CLI}" "${temp}"`, { stdio: "pipe" });
+
+    // Read result
+    const result = fs.readFileSync(temp, "utf8");
+
+    // Check expected patterns
+    for (const pattern of expectedPatterns) {
+      if (!result.includes(pattern)) {
+        throw new Error(`Expected pattern not found: ${pattern}`);
+      }
+    }
+
+    // Check unexpected patterns
+    for (const pattern of unexpectedPatterns) {
+      if (result.includes(pattern)) {
+        throw new Error(`Unexpected pattern found: ${pattern}`);
+      }
+    }
+
+    console.log(`✓ ${fixtureName}`);
+    return true;
+  } catch (err) {
+    console.error(`✗ ${fixtureName}: ${err.message}`);
+    return false;
+  } finally {
+    // Cleanup
+    if (fs.existsSync(temp)) {
+      fs.unlinkSync(temp);
+    }
+  }
+}
+
+// Run tests
+console.log("Running tests...\n");
+
+let passed = 0;
+let failed = 0;
+
+// Test 1: German quotes
+if (testFile("german.md", [
+  "\u201ETest\u201C",      // „Test"
+  "\u201EHallo Welt\u201C" // „Hallo Welt"
+])) {
+  passed++;
+} else {
+  failed++;
+}
+
+// Test 2: English quotes
+if (testFile("english.md", [
+  "\u201Ctest\u201D",        // "test"
+  "\u201CHello World\u201D"  // "Hello World"
+])) {
+  passed++;
+} else {
+  failed++;
+}
+
+// Test 3: Protected areas unchanged
+if (testFile("protected.md", [
+  'href="https://example.com"',  // HTML attribute unchanged
+  'style="color: red;"',         // HTML attribute unchanged
+  '"%Y-%m-%d"',                  // Liquid unchanged
+  'title="tooltip"',             // Kramdown unchanged
+  '`echo "test"`'                // Inline code unchanged
+], [
+  'href=\u201E',  // Should NOT have German quotes in href
+  'href=\u201C'   // Should NOT have English quotes in href
+])) {
+  passed++;
+} else {
+  failed++;
+}
+
+// Summary
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);