$2`
192 | - Description: Converts div elements to paragraph elements for cleaner Markdown conversion
193 |
194 | ### Markdown Regex Replacement Examples
195 |
196 | 1. **Add callouts to blockquotes starting with Note:**
197 | - Pattern: `> Note:(.*?)(\n\n|\n$)`
198 | - Replacement: `> [!note]$1$2`
199 | - Description: Converts simple note blockquotes to Obsidian callouts
200 | 2. **Convert URL references to Obsidian wiki links**
201 | - Pattern: `\[([^\]]+)\]\(https://en.wikipedia.org/wiki/([^\)]+)\)`
202 | - Replacement: `[[$2|$1]]`
203 | - Description: Transforms Wikipedia links to Obsidian wiki links
204 | 3. **Add tags to headings with specific keywords**
205 | - Pattern: `^(#+\s*.*?)(TODO|REVIEW|IMPORTANT)(.*)$`
206 | - Replacement: `$1$2$3 #task`
207 | - Description: Adds a task tag to headings containing action keywords
208 | 4. **Format dates consistently**
209 | - Pattern: `(\d{1,2})/(\d{1,2})/(\d{4})`
210 | - Replacement: `$3-$1-$2`
211 | - Description: Converts MM/DD/YYYY dates to YYYY-MM-DD format
212 | 5. **Convert asterisk lists to dash lists**
213 | - Pattern: `^(\s*)\*`
214 | - Replacement: `$1-`
215 | - Description: Standardizes list formatting to use dashes instead of asterisks
216 |
217 | ## License
218 |
219 | This project is licensed under the BSD Zero Clause License - see the LICENSE file for details.
220 |
--------------------------------------------------------------------------------
/src/markdownTransformer.ts:
--------------------------------------------------------------------------------
1 | // Paste Reformatter - A plugin that re-formats pasted HTML text in Obsidian.
2 | // Copyright (C) 2025 by Keath Milligan.
3 |
4 | /**
5 | * Transforms the markdown content based on the plugin settings
6 | * @param markdown The markdown content to transform
7 | * @param settings The settings to use for transformation
8 | * @param contextLevel The current heading level for contextual cascade (0 if not in a heading section)
9 | * @returns An object containing the transformed markdown content and whether any transformations were applied
10 | */
11 | export function transformMarkdown(
12 | markdown: string,
13 | settings: {
14 | markdownRegexReplacements: Array<{pattern: string, replacement: string}>,
15 | contextualCascade: boolean,
16 | maxHeadingLevel: number,
17 | cascadeHeadingLevels: boolean,
18 | stripLineBreaks: boolean,
19 | convertToSingleSpaced: boolean,
20 | removeEmptyLines: boolean
21 | },
22 | contextLevel: number = 0,
23 | escapeMarkdown: boolean = false
24 | ): { markdown: string, appliedTransformations: boolean } {
25 | let appliedTransformations = false;
26 |
27 | // Apply regex replacements if defined
28 | if (settings.markdownRegexReplacements && settings.markdownRegexReplacements.length > 0) {
29 | for (const regex_replacement of settings.markdownRegexReplacements) {
30 | try {
31 | const regex = new RegExp(regex_replacement.pattern, 'g');
32 | const replacement = regex_replacement.replacement
33 | .replace(/\\r\\n/g, '\r\n')
34 | .replace(/\\n/g, '\n')
35 | .replace(/\\r/g, '\r')
36 | .replace(/\\t/g, '\t')
37 | .replace(/\\'/g, "'")
38 | .replace(/\\"/g, '"')
39 | .replace(/\\\\/g, '\\');
40 | const originalMarkdown = markdown;
41 | // console.log(`applying ${JSON.stringify(regex_replacement.pattern)} replacement ${JSON.stringify(replacement)}`); console.log(JSON.stringify(markdown));
42 | markdown = markdown.replace(regex, replacement);
43 | if (originalMarkdown !== markdown) {
44 | appliedTransformations = true;
45 | // console.log("replaced text")
46 | }
47 | } catch (error) {
48 | console.error(`Error applying markdown regex replacement: ${error}`);
49 | }
50 | }
51 | }
52 |
53 | if (!escapeMarkdown) {
54 | // Find all heading lines
55 | const headingRegex = /^(#{1,6})\s/gm;
56 |
57 | // Process headings based on settings
58 | if (settings.contextualCascade && contextLevel > 0) {
59 | let delta = -1;
60 | let cascading = false;
61 |
62 | // Contextual cascade is enabled and we have a context level
63 | markdown = markdown.replace(headingRegex, (match, hashes) => {
64 | const currentLevel = hashes.length;
65 | let newLevel = currentLevel;
66 |
67 | if (cascading) {
68 | // Cascade subsequent levels below the context level
69 | newLevel = Math.min(currentLevel + delta, 6);
70 | console.log(`contextual cascade: delta ${delta}`);
71 | } else if (currentLevel <= contextLevel) {
72 | // Intiate contextual cascading
73 | newLevel = Math.min(contextLevel + 1, 6);
74 | delta = newLevel - currentLevel;
75 | cascading = true;
76 | console.log(`contextual cascade initiated: delta: ${delta}`);
77 | } // else nothing to do
78 |
79 | console.log(`result: current level: ${currentLevel}, new level: ${newLevel}`);
80 |
81 | appliedTransformations = (newLevel !== currentLevel);
82 | // Return the new heading with the adjusted level
83 | return '#'.repeat(newLevel) + ' ';
84 | });
85 | } else if (settings.maxHeadingLevel > 1) {
86 | let delta = -1;
87 | let cascading = false;
88 |
89 | markdown = markdown.replace(headingRegex, (match, hashes) => {
90 | const currentLevel = hashes.length;
91 | let newLevel = currentLevel;
92 |
93 | if (settings.cascadeHeadingLevels) {
94 | // If cascading is enabled, start cascading subsequent headings down if needed
95 | if (cascading) {
96 | // Cascade subsequent headers down, don't go deeper than H6
97 | newLevel = Math.min(currentLevel + delta, 6);
98 | console.log(`cascading: delta: ${delta}`);
99 | } else if (currentLevel < settings.maxHeadingLevel) {
100 | newLevel = settings.maxHeadingLevel;
101 | delta = newLevel - currentLevel;
102 | cascading = true; // we need to cascade
103 | console.log(`cascade initiated: delta: ${delta}`);
104 | } // else nothing to do, heading is good as is
105 | } else {
106 | // Cascading not enabled, just cap heading levels at max
107 | newLevel = Math.max(currentLevel, settings.maxHeadingLevel)
108 | }
109 |
110 | console.log(`result: current level: ${currentLevel}, new level: ${newLevel}`);
111 |
112 | appliedTransformations = (newLevel !== currentLevel);
113 |
114 | // Return the new heading with the adjusted level
115 | return '#'.repeat(newLevel) + ' ';
116 | });
117 | }
118 | } else {
119 | // If escaping markdown, we don't want to change headings
120 | // Just escape the markdown content
121 | const originalMarkdown = markdown;
122 |
123 | // Escape all Markdown syntax that Obsidian recognizes
124 | // Headings, bold/italic, lists, links, images, code blocks, blockquotes, etc.
125 | markdown = markdown
126 | // Escape headings
127 | .replace(/^(#{1,6}\s)/gm, '\\$1')
128 | // Escape bold/italic
129 | .replace(/(\*\*|__|\*|_)/g, '\\$1')
130 | // Escape lists
131 | .replace(/^(\s*[-+*]\s)/gm, '\\$1')
132 | // Escape numbered lists
133 | .replace(/^(\s*\d+\.\s)/gm, '\\$1')
134 | // Escape links and images
135 | .replace(/(!?\[)/g, '\\$1')
136 | // Escape code blocks and inline code
137 | .replace(/(`{1,3})/g, '\\$1')
138 | // Escape blockquotes
139 | .replace(/^(\s*>\s)/gm, '\\$1')
140 | // Escape horizontal rules
141 | .replace(/^(\s*[-*_]{3,}\s*)$/gm, '\\$1')
142 | // Escape table syntax
143 | .replace(/(\|)/g, '\\$1')
144 | // Escape task lists
145 | .replace(/^(\s*- \[ \])/gm, '\\$1')
146 | // Escape HTML tags that might be interpreted, but only if they're not already inside backticks
147 | .replace(/(`.*?`)|(<\/?[a-z][^>]*>)/gi, (match, codeContent, htmlTag) => {
148 | // If this is a code block (first capture group), return it unchanged
149 | if (codeContent) return codeContent;
150 | // Otherwise it's an HTML tag that needs escaping
151 | return htmlTag ? '`' + htmlTag + '`' : match;
152 | });
153 |
154 | appliedTransformations = (originalMarkdown !== markdown);
155 | }
156 |
157 | // First handle the special line break markers
158 | let preserveLineBreaks = !settings.stripLineBreaks;
159 |
160 | // Convert multiple consecutive blank lines to single blank line if enabled
161 | // Skip this if removeEmptyLines is enabled (optimization - lines will be removed anyway)
162 | if (settings.convertToSingleSpaced && !settings.removeEmptyLines) {
163 | // Normalize line endings to ensure consistent processing
164 | markdown = markdown.replace(/\r\n/g, '\n');
165 |
166 | // Replace 2 or more consecutive newlines with exactly 2 newlines (1 blank line)
167 | const originalMarkdown = markdown;
168 | markdown = markdown.replace(/\n{3,}/g, '\n\n');
169 |
170 | if (originalMarkdown !== markdown) {
171 | appliedTransformations = true;
172 | }
173 | }
174 |
175 | // Process empty lines with a sliding window approach
176 | if (settings.removeEmptyLines) {
177 | // First, normalize line endings to ensure consistent processing
178 | markdown = markdown.replace(/\r\n/g, '\n');
179 |
180 | // Split the content into lines
181 | const lines = markdown.split('\n');
182 | const filteredLines: string[] = [];
183 |
184 | // Sliding window processing with peek capability
185 | for (let i = 0; i < lines.length; i++) {
186 | const currentLine = lines[i];
187 | const nextLine = i + 1 < lines.length ? lines[i + 1] : null;
188 | const isCurrentLineEmpty = currentLine.trim() === '';
189 |
190 | // Rule 1: Preserve line breaks - check for special markers
191 | if (preserveLineBreaks) {
192 | const hasPreserveMarker =
193 | /]*>.*?<\/p>/.test(currentLine) ||
194 | /
]*>.*?<\/p>/.test(currentLine);
195 |
196 | if (hasPreserveMarker) {
197 | // Insert an empty line instead of the marker
198 | filteredLines.push('');
199 | continue;
200 | }
201 | }
202 |
203 | // Rule 2: Keep empty line if next line is a horizontal rule (3+ dashes)
204 | if (isCurrentLineEmpty && nextLine !== null && /^\s*-{3,}\s*$/.test(nextLine)) {
205 | filteredLines.push(currentLine);
206 | continue;
207 | }
208 |
209 | // Rule 3: Keep empty line if next line is the beginning of a table
210 | if (isCurrentLineEmpty && nextLine !== null && /^\s*\|.*\|/.test(nextLine)) {
211 | filteredLines.push(currentLine);
212 | continue;
213 | }
214 |
215 | // Default: Remove empty lines unless they meet the above criteria
216 | if (!isCurrentLineEmpty) {
217 | filteredLines.push(currentLine);
218 | }
219 | }
220 |
221 | // Join the filtered lines back together
222 | const originalMarkdown = markdown;
223 | markdown = filteredLines.join('\n');
224 | appliedTransformations = appliedTransformations || (originalMarkdown !== markdown);
225 | }
226 |
227 | return {
228 | markdown,
229 | appliedTransformations
230 | };
231 | }
232 |
--------------------------------------------------------------------------------
/openspec/AGENTS.md:
--------------------------------------------------------------------------------
1 | # OpenSpec Instructions
2 |
3 | Instructions for AI coding assistants using OpenSpec for spec-driven development.
4 |
5 | ## TL;DR Quick Checklist
6 |
7 | - Search existing work: `openspec spec list --long`, `openspec list` (use `rg` only for full-text search)
8 | - Decide scope: new capability vs modify existing capability
9 | - Pick a unique `change-id`: kebab-case, verb-led (`add-`, `update-`, `remove-`, `refactor-`)
10 | - Scaffold: `proposal.md`, `tasks.md`, `design.md` (only if needed), and delta specs per affected capability
11 | - Write deltas: use `## ADDED|MODIFIED|REMOVED|RENAMED Requirements`; include at least one `#### Scenario:` per requirement
12 | - Validate: `openspec validate [change-id] --strict` and fix issues
13 | - Request approval: Do not start implementation until proposal is approved
14 |
15 | ## Three-Stage Workflow
16 |
17 | ### Stage 1: Creating Changes
18 | Create proposal when you need to:
19 | - Add features or functionality
20 | - Make breaking changes (API, schema)
21 | - Change architecture or patterns
22 | - Optimize performance (changes behavior)
23 | - Update security patterns
24 |
25 | Triggers (examples):
26 | - "Help me create a change proposal"
27 | - "Help me plan a change"
28 | - "Help me create a proposal"
29 | - "I want to create a spec proposal"
30 | - "I want to create a spec"
31 |
32 | Loose matching guidance:
33 | - Contains one of: `proposal`, `change`, `spec`
34 | - With one of: `create`, `plan`, `make`, `start`, `help`
35 |
36 | Skip proposal for:
37 | - Bug fixes (restore intended behavior)
38 | - Typos, formatting, comments
39 | - Dependency updates (non-breaking)
40 | - Configuration changes
41 | - Tests for existing behavior
42 |
43 | **Workflow**
44 | 1. Review `openspec/project.md`, `openspec list`, and `openspec list --specs` to understand current context.
45 | 2. Choose a unique verb-led `change-id` and scaffold `proposal.md`, `tasks.md`, optional `design.md`, and spec deltas under `openspec/changes//`.
46 | 3. Draft spec deltas using `## ADDED|MODIFIED|REMOVED Requirements` with at least one `#### Scenario:` per requirement.
47 | 4. Run `openspec validate --strict` and resolve any issues before sharing the proposal.
48 |
49 | ### Stage 2: Implementing Changes
50 | Track these steps as TODOs and complete them one by one.
51 | 1. **Read proposal.md** - Understand what's being built
52 | 2. **Read design.md** (if exists) - Review technical decisions
53 | 3. **Read tasks.md** - Get implementation checklist
54 | 4. **Implement tasks sequentially** - Complete in order
55 | 5. **Confirm completion** - Ensure every item in `tasks.md` is finished before updating statuses
56 | 6. **Update checklist** - After all work is done, set every task to `- [x]` so the list reflects reality
57 | 7. **Approval gate** - Do not start implementation until the proposal is reviewed and approved
58 |
59 | ### Stage 3: Archiving Changes
60 | After deployment, create separate PR to:
61 | - Move `changes/[name]/` → `changes/archive/YYYY-MM-DD-[name]/`
62 | - Update `specs/` if capabilities changed
63 | - Use `openspec archive --skip-specs --yes` for tooling-only changes (always pass the change ID explicitly)
64 | - Run `openspec validate --strict` to confirm the archived change passes checks
65 |
66 | ## Before Any Task
67 |
68 | **Context Checklist:**
69 | - [ ] Read relevant specs in `specs/[capability]/spec.md`
70 | - [ ] Check pending changes in `changes/` for conflicts
71 | - [ ] Read `openspec/project.md` for conventions
72 | - [ ] Run `openspec list` to see active changes
73 | - [ ] Run `openspec list --specs` to see existing capabilities
74 |
75 | **Before Creating Specs:**
76 | - Always check if capability already exists
77 | - Prefer modifying existing specs over creating duplicates
78 | - Use `openspec show [spec]` to review current state
79 | - If request is ambiguous, ask 1–2 clarifying questions before scaffolding
80 |
81 | ### Search Guidance
82 | - Enumerate specs: `openspec spec list --long` (or `--json` for scripts)
83 | - Enumerate changes: `openspec list` (or `openspec change list --json` - deprecated but available)
84 | - Show details:
85 | - Spec: `openspec show --type spec` (use `--json` for filters)
86 | - Change: `openspec show --json --deltas-only`
87 | - Full-text search (use ripgrep): `rg -n "Requirement:|Scenario:" openspec/specs`
88 |
89 | ## Quick Start
90 |
91 | ### CLI Commands
92 |
93 | ```bash
94 | # Essential commands
95 | openspec list # List active changes
96 | openspec list --specs # List specifications
97 | openspec show [item] # Display change or spec
98 | openspec validate [item] # Validate changes or specs
99 | openspec archive [--yes|-y] # Archive after deployment (add --yes for non-interactive runs)
100 |
101 | # Project management
102 | openspec init [path] # Initialize OpenSpec
103 | openspec update [path] # Update instruction files
104 |
105 | # Interactive mode
106 | openspec show # Prompts for selection
107 | openspec validate # Bulk validation mode
108 |
109 | # Debugging
110 | openspec show [change] --json --deltas-only
111 | openspec validate [change] --strict
112 | ```
113 |
114 | ### Command Flags
115 |
116 | - `--json` - Machine-readable output
117 | - `--type change|spec` - Disambiguate items
118 | - `--strict` - Comprehensive validation
119 | - `--no-interactive` - Disable prompts
120 | - `--skip-specs` - Archive without spec updates
121 | - `--yes`/`-y` - Skip confirmation prompts (non-interactive archive)
122 |
123 | ## Directory Structure
124 |
125 | ```
126 | openspec/
127 | ├── project.md # Project conventions
128 | ├── specs/ # Current truth - what IS built
129 | │ └── [capability]/ # Single focused capability
130 | │ ├── spec.md # Requirements and scenarios
131 | │ └── design.md # Technical patterns
132 | ├── changes/ # Proposals - what SHOULD change
133 | │ ├── [change-name]/
134 | │ │ ├── proposal.md # Why, what, impact
135 | │ │ ├── tasks.md # Implementation checklist
136 | │ │ ├── design.md # Technical decisions (optional; see criteria)
137 | │ │ └── specs/ # Delta changes
138 | │ │ └── [capability]/
139 | │ │ └── spec.md # ADDED/MODIFIED/REMOVED
140 | │ └── archive/ # Completed changes
141 | ```
142 |
143 | ## Creating Change Proposals
144 |
145 | ### Decision Tree
146 |
147 | ```
148 | New request?
149 | ├─ Bug fix restoring spec behavior? → Fix directly
150 | ├─ Typo/format/comment? → Fix directly
151 | ├─ New feature/capability? → Create proposal
152 | ├─ Breaking change? → Create proposal
153 | ├─ Architecture change? → Create proposal
154 | └─ Unclear? → Create proposal (safer)
155 | ```
156 |
157 | ### Proposal Structure
158 |
159 | 1. **Create directory:** `changes/[change-id]/` (kebab-case, verb-led, unique)
160 |
161 | 2. **Write proposal.md:**
162 | ```markdown
163 | # Change: [Brief description of change]
164 |
165 | ## Why
166 | [1-2 sentences on problem/opportunity]
167 |
168 | ## What Changes
169 | - [Bullet list of changes]
170 | - [Mark breaking changes with **BREAKING**]
171 |
172 | ## Impact
173 | - Affected specs: [list capabilities]
174 | - Affected code: [key files/systems]
175 | ```
176 |
177 | 3. **Create spec deltas:** `specs/[capability]/spec.md`
178 | ```markdown
179 | ## ADDED Requirements
180 | ### Requirement: New Feature
181 | The system SHALL provide...
182 |
183 | #### Scenario: Success case
184 | - **WHEN** user performs action
185 | - **THEN** expected result
186 |
187 | ## MODIFIED Requirements
188 | ### Requirement: Existing Feature
189 | [Complete modified requirement]
190 |
191 | ## REMOVED Requirements
192 | ### Requirement: Old Feature
193 | **Reason**: [Why removing]
194 | **Migration**: [How to handle]
195 | ```
196 | If multiple capabilities are affected, create multiple delta files under `changes/[change-id]/specs//spec.md`—one per capability.
197 |
198 | 4. **Create tasks.md:**
199 | ```markdown
200 | ## 1. Implementation
201 | - [ ] 1.1 Create database schema
202 | - [ ] 1.2 Implement API endpoint
203 | - [ ] 1.3 Add frontend component
204 | - [ ] 1.4 Write tests
205 | ```
206 |
207 | 5. **Create design.md when needed:**
208 | Create `design.md` if any of the following apply; otherwise omit it:
209 | - Cross-cutting change (multiple services/modules) or a new architectural pattern
210 | - New external dependency or significant data model changes
211 | - Security, performance, or migration complexity
212 | - Ambiguity that benefits from technical decisions before coding
213 |
214 | Minimal `design.md` skeleton:
215 | ```markdown
216 | ## Context
217 | [Background, constraints, stakeholders]
218 |
219 | ## Goals / Non-Goals
220 | - Goals: [...]
221 | - Non-Goals: [...]
222 |
223 | ## Decisions
224 | - Decision: [What and why]
225 | - Alternatives considered: [Options + rationale]
226 |
227 | ## Risks / Trade-offs
228 | - [Risk] → Mitigation
229 |
230 | ## Migration Plan
231 | [Steps, rollback]
232 |
233 | ## Open Questions
234 | - [...]
235 | ```
236 |
237 | ## Spec File Format
238 |
239 | ### Critical: Scenario Formatting
240 |
241 | **CORRECT** (use #### headers):
242 | ```markdown
243 | #### Scenario: User login success
244 | - **WHEN** valid credentials provided
245 | - **THEN** return JWT token
246 | ```
247 |
248 | **WRONG** (don't use bullets or bold):
249 | ```markdown
250 | - **Scenario: User login** ❌
251 | **Scenario**: User login ❌
252 | ### Scenario: User login ❌
253 | ```
254 |
255 | Every requirement MUST have at least one scenario.
256 |
257 | ### Requirement Wording
258 | - Use SHALL/MUST for normative requirements (avoid should/may unless intentionally non-normative)
259 |
260 | ### Delta Operations
261 |
262 | - `## ADDED Requirements` - New capabilities
263 | - `## MODIFIED Requirements` - Changed behavior
264 | - `## REMOVED Requirements` - Deprecated features
265 | - `## RENAMED Requirements` - Name changes
266 |
267 | Headers matched with `trim(header)` - whitespace ignored.
268 |
269 | #### When to use ADDED vs MODIFIED
270 | - ADDED: Introduces a new capability or sub-capability that can stand alone as a requirement. Prefer ADDED when the change is orthogonal (e.g., adding "Slash Command Configuration") rather than altering the semantics of an existing requirement.
271 | - MODIFIED: Changes the behavior, scope, or acceptance criteria of an existing requirement. Always paste the full, updated requirement content (header + all scenarios). The archiver will replace the entire requirement with what you provide here; partial deltas will drop previous details.
272 | - RENAMED: Use when only the name changes. If you also change behavior, use RENAMED (name) plus MODIFIED (content) referencing the new name.
273 |
274 | Common pitfall: Using MODIFIED to add a new concern without including the previous text. This causes loss of detail at archive time. If you aren’t explicitly changing the existing requirement, add a new requirement under ADDED instead.
275 |
276 | Authoring a MODIFIED requirement correctly:
277 | 1) Locate the existing requirement in `openspec/specs//spec.md`.
278 | 2) Copy the entire requirement block (from `### Requirement: ...` through its scenarios).
279 | 3) Paste it under `## MODIFIED Requirements` and edit to reflect the new behavior.
280 | 4) Ensure the header text matches exactly (whitespace-insensitive) and keep at least one `#### Scenario:`.
281 |
282 | Example for RENAMED:
283 | ```markdown
284 | ## RENAMED Requirements
285 | - FROM: `### Requirement: Login`
286 | - TO: `### Requirement: User Authentication`
287 | ```
288 |
289 | ## Troubleshooting
290 |
291 | ### Common Errors
292 |
293 | **"Change must have at least one delta"**
294 | - Check `changes/[name]/specs/` exists with .md files
295 | - Verify files have operation prefixes (## ADDED Requirements)
296 |
297 | **"Requirement must have at least one scenario"**
298 | - Check scenarios use `#### Scenario:` format (4 hashtags)
299 | - Don't use bullet points or bold for scenario headers
300 |
301 | **Silent scenario parsing failures**
302 | - Exact format required: `#### Scenario: Name`
303 | - Debug with: `openspec show [change] --json --deltas-only`
304 |
305 | ### Validation Tips
306 |
307 | ```bash
308 | # Always use strict mode for comprehensive checks
309 | openspec validate [change] --strict
310 |
311 | # Debug delta parsing
312 | openspec show [change] --json | jq '.deltas'
313 |
314 | # Check specific requirement
315 | openspec show [spec] --json -r 1
316 | ```
317 |
318 | ## Happy Path Script
319 |
320 | ```bash
321 | # 1) Explore current state
322 | openspec spec list --long
323 | openspec list
324 | # Optional full-text search:
325 | # rg -n "Requirement:|Scenario:" openspec/specs
326 | # rg -n "^#|Requirement:" openspec/changes
327 |
328 | # 2) Choose change id and scaffold
329 | CHANGE=add-two-factor-auth
330 | mkdir -p openspec/changes/$CHANGE/{specs/auth}
331 | printf "## Why\n...\n\n## What Changes\n- ...\n\n## Impact\n- ...\n" > openspec/changes/$CHANGE/proposal.md
332 | printf "## 1. Implementation\n- [ ] 1.1 ...\n" > openspec/changes/$CHANGE/tasks.md
333 |
334 | # 3) Add deltas (example)
335 | cat > openspec/changes/$CHANGE/specs/auth/spec.md << 'EOF'
336 | ## ADDED Requirements
337 | ### Requirement: Two-Factor Authentication
338 | Users MUST provide a second factor during login.
339 |
340 | #### Scenario: OTP required
341 | - **WHEN** valid credentials are provided
342 | - **THEN** an OTP challenge is required
343 | EOF
344 |
345 | # 4) Validate
346 | openspec validate $CHANGE --strict
347 | ```
348 |
349 | ## Multi-Capability Example
350 |
351 | ```
352 | openspec/changes/add-2fa-notify/
353 | ├── proposal.md
354 | ├── tasks.md
355 | └── specs/
356 | ├── auth/
357 | │ └── spec.md # ADDED: Two-Factor Authentication
358 | └── notifications/
359 | └── spec.md # ADDED: OTP email notification
360 | ```
361 |
362 | auth/spec.md
363 | ```markdown
364 | ## ADDED Requirements
365 | ### Requirement: Two-Factor Authentication
366 | ...
367 | ```
368 |
369 | notifications/spec.md
370 | ```markdown
371 | ## ADDED Requirements
372 | ### Requirement: OTP Email Notification
373 | ...
374 | ```
375 |
376 | ## Best Practices
377 |
378 | ### Simplicity First
379 | - Default to <100 lines of new code
380 | - Single-file implementations until proven insufficient
381 | - Avoid frameworks without clear justification
382 | - Choose boring, proven patterns
383 |
384 | ### Complexity Triggers
385 | Only add complexity with:
386 | - Performance data showing current solution too slow
387 | - Concrete scale requirements (>1000 users, >100MB data)
388 | - Multiple proven use cases requiring abstraction
389 |
390 | ### Clear References
391 | - Use `file.ts:42` format for code locations
392 | - Reference specs as `specs/auth/spec.md`
393 | - Link related changes and PRs
394 |
395 | ### Capability Naming
396 | - Use verb-noun: `user-auth`, `payment-capture`
397 | - Single purpose per capability
398 | - 10-minute understandability rule
399 | - Split if description needs "AND"
400 |
401 | ### Change ID Naming
402 | - Use kebab-case, short and descriptive: `add-two-factor-auth`
403 | - Prefer verb-led prefixes: `add-`, `update-`, `remove-`, `refactor-`
404 | - Ensure uniqueness; if taken, append `-2`, `-3`, etc.
405 |
406 | ## Tool Selection Guide
407 |
408 | | Task | Tool | Why |
409 | |------|------|-----|
410 | | Find files by pattern | Glob | Fast pattern matching |
411 | | Search code content | Grep | Optimized regex search |
412 | | Read specific files | Read | Direct file access |
413 | | Explore unknown scope | Task | Multi-step investigation |
414 |
415 | ## Error Recovery
416 |
417 | ### Change Conflicts
418 | 1. Run `openspec list` to see active changes
419 | 2. Check for overlapping specs
420 | 3. Coordinate with change owners
421 | 4. Consider combining proposals
422 |
423 | ### Validation Failures
424 | 1. Run with `--strict` flag
425 | 2. Check JSON output for details
426 | 3. Verify spec file format
427 | 4. Ensure scenarios properly formatted
428 |
429 | ### Missing Context
430 | 1. Read project.md first
431 | 2. Check related specs
432 | 3. Review recent archives
433 | 4. Ask for clarification
434 |
435 | ## Quick Reference
436 |
437 | ### Stage Indicators
438 | - `changes/` - Proposed, not yet built
439 | - `specs/` - Built and deployed
440 | - `archive/` - Completed changes
441 |
442 | ### File Purposes
443 | - `proposal.md` - Why and what
444 | - `tasks.md` - Implementation steps
445 | - `design.md` - Technical decisions
446 | - `spec.md` - Requirements and behavior
447 |
448 | ### CLI Essentials
449 | ```bash
450 | openspec list # What's in progress?
451 | openspec show [item] # View details
452 | openspec validate --strict # Is it correct?
453 | openspec archive [--yes|-y] # Mark complete (add --yes for automation)
454 | ```
455 |
456 | Remember: Specs are truth. Changes are proposals. Keep them in sync.
457 |
--------------------------------------------------------------------------------
/src/main.ts:
--------------------------------------------------------------------------------
1 | // Paste Reformatter - A plugin that re-formats pasted HTML text in Obsidian.
2 | // Copyright (C) 2025 by Keath Milligan.
3 |
4 | import { App, MarkdownView, Plugin, PluginSettingTab, Setting, htmlToMarkdown, Notice, setIcon } from 'obsidian';
5 | import { transformHTML } from './htmlTransformer';
6 | import { transformMarkdown } from './markdownTransformer';
7 |
8 | interface RegexReplacement {
9 | pattern: string;
10 | replacement: string;
11 | }
12 |
13 | interface PasteReformmatterSettings {
14 | pasteOverride: boolean; // Whether to override the default paste behavior
15 | maxHeadingLevel: number; // The maximum heading level to allow (1-6, where 1 is disabled)
16 | removeEmptyElements: boolean; // Whether to remove empty elements when reformatting pasted content
17 | cascadeHeadingLevels: boolean; // Whether to cascade heading levels (e.g., H1→H2→H3 becomes H2→H3→H4 when max level is H2)
18 | contextualCascade: boolean; // Whether to cascade headings based on the current context (e.g., if cursor is in an H2 section, headings will start from H3)
19 | stripLineBreaks: boolean; // Whether to strip hard line breaks (br tags) when reformatting pasted content
20 | convertToSingleSpaced: boolean; // Whether to collapse multiple consecutive blank lines into a single blank line
21 | removeEmptyLines: boolean; // Whether to remove blank lines in the Markdown output
22 | htmlRegexReplacements: RegexReplacement[]; // Regular expression replacements to apply to the HTML content before converting to Markdown
23 | markdownRegexReplacements: RegexReplacement[]; // Regular expression replacements to apply to the Markdown content after HTML conversion
24 | }
25 |
26 | const DEFAULT_SETTINGS: PasteReformmatterSettings = {
27 | pasteOverride: true,
28 | maxHeadingLevel: 1,
29 | removeEmptyElements: false,
30 | cascadeHeadingLevels: true,
31 | contextualCascade: true,
32 | stripLineBreaks: false,
33 | convertToSingleSpaced: false,
34 | removeEmptyLines: false,
35 | htmlRegexReplacements: [],
36 | markdownRegexReplacements: []
37 | }
38 |
39 | export default class PasteReformatter extends Plugin {
40 | settings: PasteReformmatterSettings;
41 |
42 | async onload() {
43 | await this.loadSettings();
44 |
45 | // This adds a settings tab so the user can configure various aspects of the plugin
46 | this.addSettingTab(new PasteReformmatterSettingsTab(this.app, this));
47 |
48 | // Register paste event
49 | this.registerEvent(this.app.workspace.on("editor-paste", event => this.onPaste(event)));
50 |
51 | // Register discrete command for paste reformatting
52 | this.addCommand({
53 | id: 'reformat-and-paste',
54 | name: 'Reformat and Paste',
55 | callback: async () => {
56 | try {
57 | // Get clipboard data
58 | const dataTransfer = await this.getClipboardData();
59 | if (dataTransfer) {
60 | // Paste it into the active editor
61 | this.doPaste(dataTransfer);
62 | } else {
63 | new Notice("Clipboard does not contain HTML or plain text content.");
64 | }
65 | } catch (error) {
66 | console.error("Error accessing clipboard:", error);
67 | new Notice("Error accessing clipboard. Try using regular paste instead.");
68 | }
69 | }
70 | });
71 |
72 | // Register command to paste with all markdown escaped
73 | this.addCommand({
74 | id: 'paste-with-escaped-markdown',
75 | name: 'Paste with Escaped Markdown',
76 | callback: async () => {
77 | // Get clipboard data
78 | const dataTransfer = await this.getClipboardData();
79 | if (dataTransfer) {
80 | // Paste it into the active editor
81 | this.doPaste(dataTransfer, true);
82 | } else {
83 | new Notice("Clipboard does not contain HTML or plain text content.");
84 | }
85 | }
86 | });
87 | }
88 |
89 | onunload() {
90 | }
91 |
92 | async loadSettings() {
93 | this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
94 | }
95 |
96 | async saveSettings() {
97 | await this.saveData(this.settings);
98 | }
99 |
100 | async getClipboardData(): Promise {
101 | // Use the Clipboard API to read clipboard data
102 | try {
103 | // Get clipboard data using navigator API
104 | const clipboardItems = await navigator.clipboard.read();
105 |
106 | // Create a DataTransfer object
107 | const dataTransfer = new DataTransfer();
108 |
109 | // Process clipboard items
110 | for (const item of clipboardItems) {
111 | // Check for HTML content
112 | if (item.types.includes('text/html')) {
113 | const blob = await item.getType('text/html');
114 | const html = await blob.text();
115 | dataTransfer.setData('text/html', html);
116 | }
117 |
118 | // Check for plain text content
119 | if (item.types.includes('text/plain')) {
120 | const blob = await item.getType('text/plain');
121 | const text = await blob.text();
122 | dataTransfer.setData('text/plain', text);
123 | }
124 | }
125 |
126 | // Process the clipboard data
127 | if (dataTransfer.types.includes('text/html') || dataTransfer.types.includes('text/plain')) {
128 | return dataTransfer;
129 | } else {
130 | new Notice("Clipboard does not contain HTML or plain text content.");
131 | }
132 |
133 | } catch (error) {
134 | console.error("Error accessing clipboard:", error);
135 | new Notice("Error accessing clipboard. Try using regular paste instead.");
136 | }
137 | return null; // Return null if clipboard data is not available
138 | }
139 |
140 | doPaste(clipboardData: DataTransfer, escapeMarkdown: boolean = false): boolean {
141 | // Get the active editor using non-deprecated API
142 | const activeView = this.app.workspace.getActiveViewOfType(MarkdownView);
143 | if (!activeView) {
144 | return false;
145 | }
146 |
147 | const editor = activeView.editor;
148 | if (!editor) {
149 | return false;
150 | }
151 |
152 | try {
153 | let originalMarkdown = '';
154 | let appliedHTMLTransformations = false;
155 | let appliedMarkdownTransformations = false;
156 |
157 | // Check if HTML format is available
158 | if (clipboardData.types.includes('text/html')) {
159 | // Process as HTML
160 | const html = clipboardData.getData('text/html');
161 |
162 | // Transform HTML before converting to Markdown
163 | const result = transformHTML(html, this.settings);
164 | console.debug(`Original HTML: ${html}`);
165 | console.debug(`Transformed HTML: ${result.html}`);
166 |
167 | // Use Obsidian's built-in htmlToMarkdown function
168 | originalMarkdown = htmlToMarkdown(result.html);
169 |
170 | appliedHTMLTransformations = result.appliedTransformations;
171 | } else if (clipboardData.types.includes('text/plain')) {
172 | // Process as plain text - treat it as already being Markdown
173 | originalMarkdown = clipboardData.getData('text/plain');
174 | } else {
175 | // No supported format found
176 | console.debug("No HTML or plain text content found in clipboard");
177 | return false;
178 | }
179 |
180 | // Get the current context for contextual cascade
181 | let contextLevel = 0;
182 | if (this.settings.contextualCascade) {
183 | contextLevel = this.getCurrentHeadingLevel(editor);
184 | }
185 |
186 | // Apply settings to transform the markdown
187 | const markdownResult = transformMarkdown(originalMarkdown, this.settings, contextLevel, escapeMarkdown);
188 | appliedMarkdownTransformations = markdownResult.appliedTransformations;
189 |
190 | // Show notification
191 | if (appliedHTMLTransformations || appliedMarkdownTransformations) {
192 | // Replace the current selection with the converted markdown
193 | editor.replaceSelection(markdownResult.markdown);
194 | new Notice(`Reformatted pasted content`);
195 | return true;
196 | } else {
197 | return false;
198 | }
199 | } catch (error) {
200 | console.error("Error processing paste content:", error);
201 | new Notice("Error processing paste content");
202 | return false
203 | }
204 | }
205 |
206 | onPaste(event: ClipboardEvent) {
207 | if (this.settings.pasteOverride) {
208 | // Check if there's content in the clipboard
209 | const clipboardData = event.clipboardData;
210 | if (!clipboardData) {
211 | return;
212 | }
213 |
214 | // Process the clipboard data
215 | if (this.doPaste(clipboardData)) {
216 | // Prevent the default paste behavior
217 | console.debug("Default paste behavior overridden by Paste Reformatter plugin");
218 | event.preventDefault();
219 | } else {
220 | // If the plugin didn't handle the paste, allow the default behavior
221 | console.debug("Paste Reformatter plugin did not handle paste, allowing default behavior");
222 | }
223 | }
224 | }
225 |
226 | /**
227 | * Determines the current heading level at the cursor position
228 | * @param editor The editor instance
229 | * @returns The heading level (1-6) or 0 if not in a heading section
230 | */
231 | getCurrentHeadingLevel(editor: any): number {
232 | // Get the current cursor position
233 | const cursor = editor.getCursor();
234 | const currentLine = cursor.line;
235 |
236 | // Look backward from the current line to find the nearest heading
237 | for (let line = currentLine; line >= 0; line--) {
238 | const lineText = editor.getLine(line);
239 | const headingMatch = lineText.match(/^(#{1,6})\s/);
240 |
241 | if (headingMatch) {
242 | // Return the heading level (number of # characters)
243 | return headingMatch[1].length;
244 | }
245 | }
246 |
247 | // No heading found above the cursor
248 | return 0;
249 | }
250 | }
251 |
252 | class PasteReformmatterSettingsTab extends PluginSettingTab {
253 | plugin: PasteReformatter;
254 |
255 | constructor(app: App, plugin: PasteReformatter) {
256 | super(app, plugin);
257 | this.plugin = plugin;
258 | }
259 |
260 | private scrollNewRowIntoView(type: 'html' | 'markdown'): void {
261 | // Find the appropriate table based on type
262 | const containerClass = type === 'html' ? 'regex-replacements-container' : 'regex-replacements-container';
263 | const containers = this.containerEl.querySelectorAll('.regex-replacements-container');
264 |
265 | // Get the correct container (HTML is first, Markdown is second)
266 | const targetContainer = type === 'html' ? containers[0] : containers[1];
267 |
268 | if (targetContainer) {
269 | const table = targetContainer.querySelector('table');
270 | if (table) {
271 | const tbody = table.querySelector('tbody');
272 | if (tbody) {
273 | const rows = tbody.querySelectorAll('tr');
274 | const lastRow = rows[rows.length - 1];
275 |
276 | if (lastRow) {
277 | // Check if the row is already visible
278 | const containerRect = this.containerEl.getBoundingClientRect();
279 | const rowRect = lastRow.getBoundingClientRect();
280 |
281 | // If the row is not fully visible, scroll it into view
282 | if (rowRect.bottom > containerRect.bottom || rowRect.top < containerRect.top) {
283 | lastRow.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
284 | }
285 | }
286 | }
287 | }
288 | }
289 | }
290 |
291 | display(): void {
292 | const {containerEl} = this;
293 |
294 | containerEl.empty();
295 |
296 | new Setting(containerEl)
297 | .setName('Override default paste behavior')
298 | .setDesc('Alter the behavior of the default paste action to reformat pasted content.')
299 | .addToggle(toggle => toggle
300 | .setValue(this.plugin.settings.pasteOverride)
301 | .onChange(async (value) => {
302 | this.plugin.settings.pasteOverride = value;
303 | await this.plugin.saveSettings();
304 | }));
305 |
306 | // HTML Transformations
307 | new Setting(containerEl)
308 | .setName('HTML transformations')
309 | .setHeading()
310 | .setDesc('Control how the HTML content is processed before being converted to Markdown.');
311 |
312 | new Setting(containerEl)
313 | .setName('Remove empty elements')
314 | .setDesc('Remove empty elements when reformatting pasted content')
315 | .addToggle(toggle => toggle
316 | .setValue(this.plugin.settings.removeEmptyElements)
317 | .onChange(async (value) => {
318 | this.plugin.settings.removeEmptyElements = value;
319 | await this.plugin.saveSettings();
320 | }));
321 |
322 | new Setting(containerEl)
323 | .setName('Strip hard line breaks')
324 | .setDesc('Remove line breaks (br tags) when reformatting pasted content')
325 | .addToggle(toggle => toggle
326 | .setValue(this.plugin.settings.stripLineBreaks)
327 | .onChange(async (value) => {
328 | this.plugin.settings.stripLineBreaks = value;
329 | await this.plugin.saveSettings();
330 | }));
331 |
332 | new Setting(containerEl)
333 | .setName('HTML regex replacements')
334 | .setDesc('Apply regular expression replacements to the HTML content before converting to Markdown. You can use $1, $2, etc. to reference capture groups.');
335 |
336 | // Create a container for the regex replacement rows
337 | const regexContainer = containerEl.createDiv();
338 | regexContainer.addClass('regex-replacements-container');
339 |
340 | // Create a table for the regex replacements
341 | const table = regexContainer.createEl('table');
342 | table.addClass('regex-table');
343 |
344 | // Create the header row
345 | const thead = table.createEl('thead');
346 | const headerRow = thead.createEl('tr');
347 |
348 | // Pattern header
349 | const patternHeader = headerRow.createEl('th');
350 | patternHeader.setText('Pattern');
351 | patternHeader.addClass('regex-th');
352 | patternHeader.addClass('regex-th-pattern');
353 |
354 | // Replacement header
355 | const replacementHeader = headerRow.createEl('th');
356 | replacementHeader.setText('Replacement');
357 | replacementHeader.addClass('regex-th');
358 | replacementHeader.addClass('regex-th-replacement');
359 |
360 | // Actions header
361 | const actionsHeader = headerRow.createEl('th');
362 | actionsHeader.addClass('regex-th');
363 | actionsHeader.addClass('regex-th-actions');
364 |
365 | // Create the table body
366 | const tbody = table.createEl('tbody');
367 |
368 | // Add a row for each replacement
369 | this.plugin.settings.htmlRegexReplacements.forEach((replacement, index) => {
370 | const row = tbody.createEl('tr');
371 |
372 | // Pattern cell
373 | const patternCell = row.createEl('td');
374 | patternCell.addClass('regex-td');
375 |
376 | // Pattern input
377 | const patternInput = document.createElement('input');
378 | patternInput.type = 'text';
379 | patternInput.value = replacement.pattern;
380 | patternInput.placeholder = 'Regular expression pattern';
381 | patternInput.addClass('regex-input');
382 | patternInput.addEventListener('change', async () => {
383 | this.plugin.settings.htmlRegexReplacements[index].pattern = patternInput.value;
384 | await this.plugin.saveSettings();
385 | });
386 | patternCell.appendChild(patternInput);
387 |
388 | // Replacement cell
389 | const replacementCell = row.createEl('td');
390 | replacementCell.addClass('regex-td');
391 |
392 | // Replacement input
393 | const replacementInput = document.createElement('input');
394 | replacementInput.type = 'text';
395 | replacementInput.value = replacement.replacement;
396 | replacementInput.placeholder = 'Replacement value (can use $1, $2, etc.)';
397 | replacementInput.addClass('regex-input');
398 | replacementInput.addEventListener('change', async () => {
399 | this.plugin.settings.htmlRegexReplacements[index].replacement = replacementInput.value;
400 | await this.plugin.saveSettings();
401 | });
402 | replacementCell.appendChild(replacementInput);
403 |
404 | // Actions cell
405 | const actionsCell = row.createEl('td');
406 | actionsCell.addClass('regex-td');
407 | actionsCell.addClass('regex-td-actions');
408 |
409 | // Remove icon
410 | const removeIcon = document.createElement('span');
411 | removeIcon.className = 'regex-remove-icon';
412 | removeIcon.setAttribute('title', 'Delete');
413 | removeIcon.setAttribute('aria-label', 'Delete');
414 | removeIcon.setAttribute('role', 'button');
415 | removeIcon.setAttribute('tabindex', '0');
416 | setIcon(removeIcon, 'trash-2');
417 | removeIcon.addEventListener('click', async () => {
418 | this.plugin.settings.htmlRegexReplacements.splice(index, 1);
419 | await this.plugin.saveSettings();
420 | this.display(); // Refresh the display
421 | });
422 | // Add keyboard support for accessibility
423 | removeIcon.addEventListener('keydown', (e) => {
424 | if (e.key === 'Enter' || e.key === ' ') {
425 | e.preventDefault();
426 | removeIcon.click();
427 | }
428 | });
429 | actionsCell.appendChild(removeIcon);
430 | });
431 |
432 | // Add a message if no replacements are defined
433 | if (this.plugin.settings.htmlRegexReplacements.length === 0) {
434 | const emptyRow = tbody.createEl('tr');
435 | const emptyCell = emptyRow.createEl('td');
436 | emptyCell.colSpan = 3;
437 | emptyCell.addClass('regex-empty-message');
438 | emptyCell.setText('No replacements defined. Click the + icon below to add one.');
439 | }
440 |
441 | // Add plus-circle icon for adding new HTML replacements
442 | const htmlAddIcon = regexContainer.createEl('div');
443 | htmlAddIcon.className = 'regex-add-icon';
444 | htmlAddIcon.setAttribute('title', 'Add replacement');
445 | htmlAddIcon.setAttribute('aria-label', 'Add replacement');
446 | htmlAddIcon.setAttribute('role', 'button');
447 | htmlAddIcon.setAttribute('tabindex', '0');
448 | setIcon(htmlAddIcon, 'plus-circle');
449 | htmlAddIcon.addEventListener('click', () => {
450 | // Check if there's already an empty row
451 | const hasEmptyRow = this.plugin.settings.htmlRegexReplacements.some(
452 | replacement => replacement.pattern === '' && replacement.replacement === ''
453 | );
454 |
455 | // Only add a new row if there isn't already an empty one
456 | if (!hasEmptyRow) {
457 | // Add a new empty replacement
458 | this.plugin.settings.htmlRegexReplacements.push({
459 | pattern: '',
460 | replacement: ''
461 | });
462 | // Save settings and refresh display, preserving scroll position and scrolling new row into view if needed
463 | const scrollTop = this.containerEl.scrollTop;
464 | this.plugin.saveSettings().then(() => {
465 | this.display();
466 | // Restore original scroll position
467 | this.containerEl.scrollTop = scrollTop;
468 | // Then scroll the newly added row into view if it's not visible
469 | this.scrollNewRowIntoView('html');
470 | });
471 | }
472 | });
473 | // Add keyboard support for accessibility
474 | htmlAddIcon.addEventListener('keydown', (e) => {
475 | if (e.key === 'Enter' || e.key === ' ') {
476 | e.preventDefault();
477 | htmlAddIcon.click();
478 | }
479 | });
480 |
481 | new Setting(containerEl)
482 | .setName('Markdown transformations')
483 | .setDesc('Control how the Markdown content is adjusted after HTML conversion or when pasted as plain text.')
484 | .setHeading();
485 |
486 | new Setting(containerEl)
487 | .setName('Max heading level')
488 | .setDesc('The maximum heading level to allow when reformatting pasted content (H1 is treated as disabled)')
489 | .addDropdown(dropdown => dropdown
490 | .addOptions({
491 | '1': 'Disabled (H1)',
492 | '2': 'H2',
493 | '3': 'H3',
494 | '4': 'H4',
495 | '5': 'H5',
496 | '6': 'H6'
497 | })
498 | .setValue(this.plugin.settings.maxHeadingLevel.toString())
499 | .onChange(async (value) => {
500 | this.plugin.settings.maxHeadingLevel = parseInt(value);
501 | await this.plugin.saveSettings();
502 |
503 | // Always refresh the display to update the cascade heading levels toggle visibility
504 | this.display();
505 | }));
506 |
507 | // Only show cascade heading levels setting if max heading level is not H1 (disabled)
508 | if (this.plugin.settings.maxHeadingLevel > 1) {
509 | new Setting(containerEl)
510 | .setName('Cascade heading levels')
511 | .setDesc('Preserve the heading hierarchy by cascading levels (e.g., H1→H2→H3 becomes H2→H3→H4 when max level is H2)')
512 | .addToggle(toggle => toggle
513 | .setValue(this.plugin.settings.cascadeHeadingLevels)
514 | .onChange(async (value) => {
515 | this.plugin.settings.cascadeHeadingLevels = value;
516 | await this.plugin.saveSettings();
517 | }));
518 | }
519 |
520 | new Setting(containerEl)
521 | .setName('Contextual cascade')
522 | .setDesc('Cascade headings based on the current context (e.g., if cursor is in an H2 section, headings will start from H3)')
523 | .addToggle(toggle => toggle
524 | .setValue(this.plugin.settings.contextualCascade)
525 | .onChange(async (value) => {
526 | this.plugin.settings.contextualCascade = value;
527 | await this.plugin.saveSettings();
528 | }));
529 |
530 | const singleSpacedSetting = new Setting(containerEl)
531 | .setName('Convert to single-spaced')
532 | .setDesc('Collapse multiple consecutive blank lines into a single blank line')
533 | .addToggle(toggle => toggle
534 | .setValue(this.plugin.settings.convertToSingleSpaced)
535 | .setDisabled(this.plugin.settings.removeEmptyLines)
536 | .onChange(async (value) => {
537 | this.plugin.settings.convertToSingleSpaced = value;
538 | await this.plugin.saveSettings();
539 | }));
540 |
541 | // Add visual indication when disabled
542 | if (this.plugin.settings.removeEmptyLines) {
543 | singleSpacedSetting.settingEl.addClass('paste-reformatter-disabled-setting');
544 | }
545 |
546 | new Setting(containerEl)
547 | .setName('Remove empty lines')
548 | .setDesc('Remove blank lines in the Markdown output')
549 | .addToggle(toggle => toggle
550 | .setValue(this.plugin.settings.removeEmptyLines)
551 | .onChange(async (value) => {
552 | this.plugin.settings.removeEmptyLines = value;
553 | await this.plugin.saveSettings();
554 |
555 | // Refresh the display to update the disabled state of "Convert to single-spaced"
556 | this.display();
557 | }));
558 |
559 | new Setting(containerEl)
560 | .setName('Markdown regex replacements')
561 | .setDesc('Apply regular expression replacements to the Markdown content after HTML conversion. You can use $1, $2, etc. to reference capture groups.');
562 |
563 | // Create a container for the regex replacement rows
564 | const markdownRegexContainer = containerEl.createDiv();
565 | markdownRegexContainer.addClass('regex-replacements-container');
566 |
567 | // Create a table for the regex replacements
568 | const markdownRegexTable = markdownRegexContainer.createEl('table');
569 | markdownRegexTable.addClass('regex-table');
570 |
571 | // Create the header row
572 | const markdownRegexThead = markdownRegexTable.createEl('thead');
573 | const markdownRegexHeaderRow = markdownRegexThead.createEl('tr');
574 |
575 | // Pattern header
576 | const markdownRegexPatternHeader = markdownRegexHeaderRow.createEl('th');
577 | markdownRegexPatternHeader.setText('Pattern');
578 | markdownRegexPatternHeader.addClass('regex-th');
579 | markdownRegexPatternHeader.addClass('regex-th-pattern');
580 |
581 | // Replacement header
582 | const markdownRegexReplacementHeader = markdownRegexHeaderRow.createEl('th');
583 | markdownRegexReplacementHeader.setText('Replacement');
584 | markdownRegexReplacementHeader.addClass('regex-th');
585 | markdownRegexReplacementHeader.addClass('regex-th-replacement');
586 |
587 | // Actions header
588 | const markdownRegexActionsHeader = markdownRegexHeaderRow.createEl('th');
589 | markdownRegexActionsHeader.addClass('regex-th');
590 | markdownRegexActionsHeader.addClass('regex-th-actions');
591 |
592 | // Create the table body
593 | const markdownRegexTbody = markdownRegexTable.createEl('tbody');
594 |
595 | // Add a row for each replacement
596 | this.plugin.settings.markdownRegexReplacements.forEach((replacement, index) => {
597 | const row = markdownRegexTbody.createEl('tr');
598 |
599 | // Pattern cell
600 | const patternCell = row.createEl('td');
601 | patternCell.addClass('regex-td');
602 |
603 | // Pattern input
604 | const patternInput = document.createElement('input');
605 | patternInput.type = 'text';
606 | patternInput.value = replacement.pattern;
607 | patternInput.placeholder = 'Regular expression pattern';
608 | patternInput.addClass('regex-input');
609 | patternInput.addEventListener('change', async () => {
610 | this.plugin.settings.markdownRegexReplacements[index].pattern = patternInput.value;
611 | await this.plugin.saveSettings();
612 | });
613 | patternCell.appendChild(patternInput);
614 |
615 | // Replacement cell
616 | const replacementCell = row.createEl('td');
617 | replacementCell.addClass('regex-td');
618 |
619 | // Replacement input
620 | const replacementInput = document.createElement('input');
621 | replacementInput.type = 'text';
622 | replacementInput.value = replacement.replacement;
623 | replacementInput.placeholder = 'Replacement value (can use $1, $2, etc.)';
624 | replacementInput.addClass('regex-input');
625 | replacementInput.addEventListener('change', async () => {
626 | this.plugin.settings.markdownRegexReplacements[index].replacement = replacementInput.value;
627 | await this.plugin.saveSettings();
628 | });
629 | replacementCell.appendChild(replacementInput);
630 |
631 | // Actions cell
632 | const actionsCell = row.createEl('td');
633 | actionsCell.addClass('regex-td');
634 | actionsCell.addClass('regex-td-actions');
635 |
636 | // Remove icon
637 | const removeIcon = document.createElement('span');
638 | removeIcon.className = 'regex-remove-icon';
639 | removeIcon.setAttribute('title', 'Delete');
640 | removeIcon.setAttribute('aria-label', 'Delete');
641 | removeIcon.setAttribute('role', 'button');
642 | removeIcon.setAttribute('tabindex', '0');
643 | setIcon(removeIcon, 'trash-2');
644 | removeIcon.addEventListener('click', async () => {
645 | this.plugin.settings.markdownRegexReplacements.splice(index, 1);
646 | await this.plugin.saveSettings();
647 | this.display(); // Refresh the display
648 | });
649 | // Add keyboard support for accessibility
650 | removeIcon.addEventListener('keydown', (e) => {
651 | if (e.key === 'Enter' || e.key === ' ') {
652 | e.preventDefault();
653 | removeIcon.click();
654 | }
655 | });
656 | actionsCell.appendChild(removeIcon);
657 | });
658 |
659 | // Add a message if no replacements are defined
660 | if (this.plugin.settings.markdownRegexReplacements.length === 0) {
661 | const emptyRow = markdownRegexTbody.createEl('tr');
662 | const emptyCell = emptyRow.createEl('td');
663 | emptyCell.colSpan = 3;
664 | emptyCell.addClass('regex-empty-message');
665 | emptyCell.setText('No replacements defined. Click the + icon below to add one.');
666 | }
667 |
668 | // Add plus-circle icon for adding new Markdown replacements
669 | const markdownAddIcon = markdownRegexContainer.createEl('div');
670 | markdownAddIcon.className = 'regex-add-icon';
671 | markdownAddIcon.setAttribute('title', 'Add replacement');
672 | markdownAddIcon.setAttribute('aria-label', 'Add replacement');
673 | markdownAddIcon.setAttribute('role', 'button');
674 | markdownAddIcon.setAttribute('tabindex', '0');
675 | setIcon(markdownAddIcon, 'plus-circle');
676 | markdownAddIcon.addEventListener('click', () => {
677 | // Check if there's already an empty row
678 | const hasEmptyRow = this.plugin.settings.markdownRegexReplacements.some(
679 | replacement => replacement.pattern === '' && replacement.replacement === ''
680 | );
681 |
682 | // Only add a new row if there isn't already an empty one
683 | if (!hasEmptyRow) {
684 | // Add a new empty replacement
685 | this.plugin.settings.markdownRegexReplacements.push({
686 | pattern: '',
687 | replacement: ''
688 | });
689 | // Save settings and refresh display, preserving scroll position and scrolling new row into view if needed
690 | const scrollTop = this.containerEl.scrollTop;
691 | this.plugin.saveSettings().then(() => {
692 | this.display();
693 | // Restore original scroll position
694 | this.containerEl.scrollTop = scrollTop;
695 | // Then scroll the newly added row into view if it's not visible
696 | this.scrollNewRowIntoView('markdown');
697 | });
698 | }
699 | });
700 | // Add keyboard support for accessibility
701 | markdownAddIcon.addEventListener('keydown', (e) => {
702 | if (e.key === 'Enter' || e.key === ' ') {
703 | e.preventDefault();
704 | markdownAddIcon.click();
705 | }
706 | });
707 | }
708 |
709 | }
710 |
--------------------------------------------------------------------------------