feat: remove quote requirement from repeat() macro

- Changed syntax from repeat('[C]', 3) to repeat([C], 3)
- Parser now collects SELFIES tokens directly instead of string
- Updated all tests and fixtures to use new syntax
- Added repeat examples to README.md
- Fixed analyzer getDependencies() to handle REPEAT_CALL tokens
- All 625 tests passing

🤖 Generated with Claude Code

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: Ghost---Shadow

README.md

@@ -112,6 +112,11 @@ selfies list molecules.selfies
 # Reference other fragments
 [ethanol] = [ethyl][hydroxyl]
 
+# Use repeat() macro for patterns
+[benzene] = repeat([C][=C], 3)[Ring1][=Branch1]
+[carbon_chain] = repeat([C], 10)
+[polymer] = repeat([monomer], 5)
+
 # Import from other files
 import "./other-file.selfies"                    # import all
 import [methyl, ethyl] from "./fragments.selfies" # import specific
@@ -156,6 +161,33 @@ await initRDKit()
 const svg = await renderSelfies('[C][C][O]', { width: 300, height: 300 })
 ```
 
+## Repeat Macro
+
+The `repeat()` macro allows you to repeat molecular patterns, perfect for polymers and long chains:
+
+```selfies
+# Benzene ring
+[benzene] = repeat([C][=C], 3)[Ring1][=Branch1]
+
+# Carbon chains
+[decane] = repeat([C], 10)
+[pentadecane] = repeat([C], 15)
+
+# Polymer repeat units
+[PE_unit] = [C][C]
+[polyethylene_trimer] = repeat([PE_unit], 3)
+
+# References work too
+[monomer] = [C][Branch1][C][Cl][C]
+[pvc_hexamer] = repeat([monomer], 6)
+```
+
+The pattern can be:
+- **Primitive tokens**: `repeat([C], 10)` for a 10-carbon chain
+- **Complex patterns**: `repeat([C][=C], 3)` for alternating double bonds
+- **Named references**: `repeat([unit], 5)` to repeat a defined fragment
+- **Combined**: `[molecule] = [N]repeat([C], 3)[O]` with tokens before/after
+
 ## VS Code Extension
 
 Get live visualization as you author `.selfies` files. See the molecular structure update line-by-line as you navigate your code.

src/dsl/analyzer.js

@@ -25,17 +25,60 @@ export function getDependencies(program, name) {
 
   const dependencies = []
   for (const token of definition.tokens) {
-    const tokenName = token.slice(1, -1) // Remove brackets
-    if (program.definitions.has(tokenName)) {
-      if (!dependencies.includes(tokenName)) {
-        dependencies.push(tokenName)
+    if (typeof token === 'object' && token.type === 'REPEAT_CALL') {
+      // Extract dependencies from repeat pattern
+      const patternTokens = tokenizePattern(token.pattern)
+      for (const patternToken of patternTokens) {
+        const tokenName = patternToken.slice(1, -1) // Remove brackets
+        if (program.definitions.has(tokenName)) {
+          if (!dependencies.includes(tokenName)) {
+            dependencies.push(tokenName)
+          }
+        }
+      }
+    } else if (typeof token === 'string') {
+      const tokenName = token.slice(1, -1) // Remove brackets
+      if (program.definitions.has(tokenName)) {
+        if (!dependencies.includes(tokenName)) {
+          dependencies.push(tokenName)
+        }
       }
     }
   }
 
   return dependencies
 }
 
+/**
+ * Tokenizes a pattern string into SELFIES tokens
+ * @param {string} pattern - Pattern string like '[C][=C]'
+ * @returns {string[]} Array of tokens
+ */
+function tokenizePattern(pattern) {
+  const tokens = []
+  let i = 0
+
+  while (i < pattern.length) {
+    if (pattern[i] === '[') {
+      // Find the closing bracket
+      let j = i + 1
+      while (j < pattern.length && pattern[j] !== ']') {
+        j++
+      }
+      if (j < pattern.length) {
+        tokens.push(pattern.slice(i, j + 1))
+        i = j + 1
+      } else {
+        i++
+      }
+    } else {
+      i++
+    }
+  }
+
+  return tokens
+}
+
 /**
  * Gets the names that depend on a definition
  * @param {Object} program - Program object

src/dsl/parser.js

@@ -222,18 +222,37 @@ function parseRepeatCall(tokens, startIndex) {
   }
   i++
 
-  // Expect STRING (pattern)
-  if (i >= tokens.length || tokens[i].type !== TokenType.STRING) {
-    // Skip to closing paren or end of line on error
+  // Collect SELFIES_TOKENs as pattern until we hit COMMA
+  const patternTokens = []
+  const patternStart = i
+
+  while (i < tokens.length &&
+         tokens[i].type !== TokenType.COMMA &&
+         tokens[i].type !== TokenType.RPAREN &&
+         tokens[i].type !== TokenType.NEWLINE &&
+         tokens[i].type !== TokenType.EOF) {
+    if (tokens[i].type === TokenType.SELFIES_TOKEN) {
+      patternTokens.push(tokens[i].value)
+      i++
+    } else {
+      const skipToEnd = skipToRParenOrEOL(tokens, i)
+      return {
+        error: createDiagnostic('Expected SELFIES tokens or name references in pattern', 'error', tokens[i]),
+        nextIndex: skipToEnd
+      }
+    }
+  }
+
+  if (patternTokens.length === 0) {
     const skipToEnd = skipToRParenOrEOL(tokens, i)
     return {
-      error: createDiagnostic('Expected string pattern as first argument', 'error', tokens[i] || repeatToken),
+      error: createDiagnostic('Pattern cannot be empty', 'error', tokens[patternStart] || repeatToken),
       nextIndex: skipToEnd
     }
   }
-  const patternToken = tokens[i]
-  const pattern = patternToken.value.slice(1, -1) // Remove quotes
-  i++
+
+  // Join pattern tokens into a single string
+  const pattern = patternTokens.join('')
 
   // Expect COMMA
   if (i >= tokens.length || tokens[i].type !== TokenType.COMMA) {

src/dsl/resolver.test.js

@@ -100,81 +100,82 @@ describe('resolveAll', () => {
 
 describe('repeat macro', () => {
   test('repeats a simple token sequence', () => {
-    const program = parse('[triple_carbon] = repeat(\'[C]\', 3)')
+    const program = parse('[triple_carbon] = repeat([C], 3)')
     expect(resolve(program, 'triple_carbon')).toBe('[C][C][C]')
   })
 
   test('repeats a complex token sequence', () => {
-    const program = parse('[benzene] = repeat(\'[C][=C]\', 3)[Ring1][=Branch1]')
+    const program = parse('[benzene] = repeat([C][=C], 3)[Ring1][=Branch1]')
     expect(resolve(program, 'benzene')).toBe('[C][=C][C][=C][C][=C][Ring1][=Branch1]')
   })
 
   test('repeats with count of 1', () => {
-    const program = parse('[single] = repeat(\'[C][O]\', 1)')
+    const program = parse('[single] = repeat([C][O], 1)')
     expect(resolve(program, 'single')).toBe('[C][O]')
   })
 
   test('repeats with count of 0 produces empty sequence', () => {
-    const program = parse('[empty] = [C]repeat(\'[O]\', 0)[C]')
+    const program = parse('[empty] = [C]repeat([O], 0)[C]')
     expect(resolve(program, 'empty')).toBe('[C][C]')
   })
 
   test('repeat with reference to other definition', () => {
-    const source = '[unit] = [C][=C]\n[triple] = repeat(\'[unit]\', 3)'
+    const source = '[unit] = [C][=C]\n[triple] = repeat([unit], 3)'
     const program = parse(source)
     expect(resolve(program, 'triple')).toBe('[C][=C][C][=C][C][=C]')
   })
 
   test('multiple repeat calls in one definition', () => {
-    const program = parse('[chain] = repeat(\'[C]\', 2)repeat(\'[O]\', 2)')
+    const program = parse('[chain] = repeat([C], 2)repeat([O], 2)')
     expect(resolve(program, 'chain')).toBe('[C][C][O][O]')
   })
 
   test('repeat combined with regular tokens', () => {
-    const program = parse('[molecule] = [N]repeat(\'[C]\', 3)[O]')
+    const program = parse('[molecule] = [N]repeat([C], 3)[O]')
     expect(resolve(program, 'molecule')).toBe('[N][C][C][C][O]')
   })
 
   test('repeat with nested brackets in pattern', () => {
-    const program = parse('[branched] = repeat(\'[C][Branch1][C][O]\', 2)')
+    const program = parse('[branched] = repeat([C][Branch1][C][O], 2)')
     expect(resolve(program, 'branched')).toBe('[C][Branch1][C][O][C][Branch1][C][O]')
   })
 
   test('throws error on invalid repeat count', () => {
-    const program = parse('[bad] = repeat(\'[C]\', -1)')
+    const program = parse('[bad] = repeat([C], -1)')
     expect(() => resolve(program, 'bad')).toThrow(/count must be/)
   })
 
   test('throws error on non-numeric count', () => {
-    const program = parse('[bad] = repeat(\'[C]\', abc)')
+    const program = parse('[bad] = repeat([C], abc)')
     expect(() => resolve(program, 'bad')).toThrow()
   })
 
   test('throws error on missing arguments', () => {
-    const program = parse('[bad] = repeat(\'[C]\')')
+    const program = parse('[bad] = repeat([C])')
     expect(() => resolve(program, 'bad')).toThrow()
   })
 
-  test('throws error on malformed repeat syntax', () => {
-    const program = parse('[bad] = repeat([C], 3)')
-    expect(() => resolve(program, 'bad')).toThrow()
+  test('throws error on empty pattern', () => {
+    const program = parse('[bad] = repeat(, 3)')
+    // Parse error results in empty definition
+    expect(() => resolve(program, 'bad')).toThrow(/no tokens/)
   })
 
   test('simple polymer-like chain', () => {
-    const source = '[ch2] = [C]\n[polymer_chain] = repeat(\'[ch2]\', 5)'
+    const source = '[ch2] = [C]\n[polymer_chain] = repeat([ch2], 5)'
     const program = parse(source)
     expect(resolve(program, 'polymer_chain')).toBe('[C][C][C][C][C]')
   })
 
   test('polymer chain with decode', () => {
-    const source = '[ch2] = [C]\n[polymer_chain] = repeat(\'[ch2]\', 5)'
+    const source = '[ch2] = [C]\n[polymer_chain] = repeat([ch2], 5)'
     const program = parse(source)
     expect(resolve(program, 'polymer_chain', { decode: true })).toBe('CCCCC')
   })
 
   test('vinyl chloride monomer units', () => {
     // Each monomer as a branch structure for proper chemistry
-    const source = '[monomer] = [C][Branch1][C][Cl][C]\n[polymer] = repeat(\'[monomer]\', 3)'
+    const source = '[monomer] = [C][Branch1][C][Cl][C]\n[polymer] = repeat([monomer], 3)'
     const program = parse(source)
     // This creates a branched structure: C(Cl)CC(Cl)CC(Cl)C
     expect(resolve(program, 'polymer')).toBe('[C][Branch1][C][Cl][C][C][Branch1][C][Cl][C][C][Branch1][C][Cl][C]')

test/fixtures/programs/polymers.selfies

@@ -30,3 +30,12 @@
 # Polyester building blocks
 [ethylene_glycol] = [C][C][hydroxyl][hydroxyl]
 [terephthalic_acid] = [phenyl][carboxyl][carboxyl]
+
+# Using repeat() macro for polymer chains
+[PE_trimer] = repeat([PE_unit], 3)
+[PP_pentamer] = repeat([PP_unit], 5)
+[PS_tetramer] = repeat([PS_unit], 4)
+[PVC_hexamer] = repeat([PVC_unit], 6)
+
+# Carbon chain using repeat
+[decane_chain] = repeat([C], 10)

test/fixtures/programs/reuse-patterns.selfies

@@ -14,6 +14,12 @@
 [pentane] = [m][m][m][m][m]
 [hexane] = [m][m][m][m][m][m]
 
+# Same patterns using repeat() macro
+[heptane] = repeat([m], 7)
+[octane] = repeat([m], 8)
+[nonane] = repeat([m], 9)
+[decane] = repeat([m], 10)
+
 # ═══════════════════════════════════════════════════════════════
 #  REUSE ACROSS MULTIPLE DEFINITIONS
 # ═══════════════════════════════════════════════════════════════
@@ -46,6 +52,10 @@
 [aaaa] = [aa][aa]
 [aaaaaaaa] = [aaaa][aaaa]
 
+# Using repeat for longer chains
+[a16] = repeat([a], 16)
+[a32] = repeat([a], 32)
+
 # ═══════════════════════════════════════════════════════════════
 #  REUSE WITH DIFFERENT COMPOSITIONS
 # ═══════════════════════════════════════════════════════════════