opencode-snippets 1.1.2 → 1.2.0

package/src/expander.test.ts

@@ -0,0 +1,456 @@
+import { expandHashtags } from "../src/expander.js";
+import type { SnippetRegistry } from "../src/types.js";
+
+describe("expandHashtags - Recursive Includes and Loop Detection", () => {
+  describe("Basic expansion", () => {
+    it("should expand a single hashtag", () => {
+      const registry: SnippetRegistry = new Map([["greeting", "Hello, World!"]]);
+
+      const result = expandHashtags("Say #greeting", registry);
+
+      expect(result).toBe("Say Hello, World!");
+    });
+
+    it("should expand multiple hashtags in one text", () => {
+      const registry: SnippetRegistry = new Map([
+        ["greeting", "Hello"],
+        ["name", "Alice"],
+      ]);
+
+      const result = expandHashtags("#greeting, #name!", registry);
+
+      expect(result).toBe("Hello, Alice!");
+    });
+
+    it("should leave unknown hashtags unchanged", () => {
+      const registry: SnippetRegistry = new Map([["known", "content"]]);
+
+      const result = expandHashtags("This is #known and #unknown", registry);
+
+      expect(result).toBe("This is content and #unknown");
+    });
+
+    it("should handle empty text", () => {
+      const registry: SnippetRegistry = new Map([["test", "content"]]);
+
+      const result = expandHashtags("", registry);
+
+      expect(result).toBe("");
+    });
+
+    it("should handle text with no hashtags", () => {
+      const registry: SnippetRegistry = new Map([["test", "content"]]);
+
+      const result = expandHashtags("No hashtags here", registry);
+
+      expect(result).toBe("No hashtags here");
+    });
+
+    it("should handle case-insensitive hashtags", () => {
+      const registry: SnippetRegistry = new Map([["greeting", "Hello"]]);
+
+      const result = expandHashtags("#Greeting #GREETING #greeting", registry);
+
+      expect(result).toBe("Hello Hello Hello");
+    });
+  });
+
+  describe("Recursive expansion", () => {
+    it("should expand nested hashtags one level deep", () => {
+      const registry: SnippetRegistry = new Map([
+        ["outer", "Start #inner End"],
+        ["inner", "Middle"],
+      ]);
+
+      const result = expandHashtags("#outer", registry);
+
+      expect(result).toBe("Start Middle End");
+    });
+
+    it("should expand nested hashtags multiple levels deep", () => {
+      const registry: SnippetRegistry = new Map([
+        ["level1", "L1 #level2"],
+        ["level2", "L2 #level3"],
+        ["level3", "L3 #level4"],
+        ["level4", "L4"],
+      ]);
+
+      const result = expandHashtags("#level1", registry);
+
+      expect(result).toBe("L1 L2 L3 L4");
+    });
+
+    it("should expand multiple nested hashtags in one snippet", () => {
+      const registry: SnippetRegistry = new Map([
+        ["main", "Start #a and #b End"],
+        ["a", "Content A"],
+        ["b", "Content B"],
+      ]);
+
+      const result = expandHashtags("#main", registry);
+
+      expect(result).toBe("Start Content A and Content B End");
+    });
+
+    it("should expand complex nested structure", () => {
+      const registry: SnippetRegistry = new Map([
+        ["greeting", "#hello #name"],
+        ["hello", "Hello"],
+        ["name", "#firstname #lastname"],
+        ["firstname", "John"],
+        ["lastname", "Doe"],
+      ]);
+
+      const result = expandHashtags("#greeting", registry);
+
+      expect(result).toBe("Hello John Doe");
+    });
+  });
+
+  describe("Loop detection - Direct cycles", () => {
+    it("should detect and prevent simple self-reference", { timeout: 100 }, () => {
+      const registry: SnippetRegistry = new Map([["self", "I reference #self"]]);
+
+      const result = expandHashtags("#self", registry);
+
+      // Loop detected after 15 expansions, #self left as-is
+      const expected = `${"I reference ".repeat(15)}#self`;
+      expect(result).toBe(expected);
+    });
+
+    it("should detect and prevent two-way circular reference", () => {
+      const registry: SnippetRegistry = new Map([
+        ["a", "A references #b"],
+        ["b", "B references #a"],
+      ]);
+
+      const result = expandHashtags("#a", registry);
+
+      // Should expand alternating A and B 15 times then stop
+      const expected = `${"A references B references ".repeat(15)}#a`;
+      expect(result).toBe(expected);
+    });
+
+    it("should detect and prevent three-way circular reference", () => {
+      const registry: SnippetRegistry = new Map([
+        ["a", "A -> #b"],
+        ["b", "B -> #c"],
+        ["c", "C -> #a"],
+      ]);
+
+      const result = expandHashtags("#a", registry);
+
+      // Should expand cycling through A, B, C 15 times then stop
+      const expected = `${"A -> B -> C -> ".repeat(15)}#a`;
+      expect(result).toBe(expected);
+    });
+
+    it("should detect loops in longer chains", () => {
+      const registry: SnippetRegistry = new Map([
+        ["a", "#b"],
+        ["b", "#c"],
+        ["c", "#d"],
+        ["d", "#e"],
+        ["e", "#b"], // Loop back to b
+      ]);
+
+      const result = expandHashtags("#a", registry);
+
+      // Should expand until loop detected
+      expect(result).toBe("#b");
+    });
+  });
+
+  describe("Loop detection - Complex scenarios", () => {
+    it("should allow same snippet in different branches", () => {
+      const registry: SnippetRegistry = new Map([
+        ["main", "#branch1 and #branch2"],
+        ["branch1", "B1 uses #shared"],
+        ["branch2", "B2 uses #shared"],
+        ["shared", "Shared content"],
+      ]);
+
+      const result = expandHashtags("#main", registry);
+
+      // #shared should be expanded in both branches
+      expect(result).toBe("B1 uses Shared content and B2 uses Shared content");
+    });
+
+    it("should handle partial loops with valid branches", () => {
+      const registry: SnippetRegistry = new Map([
+        ["main", "#valid and #loop"],
+        ["valid", "Valid content"],
+        ["loop", "Loop #loop"],
+      ]);
+
+      const result = expandHashtags("#main", registry);
+
+      // Valid expands once, loop expands 15 times
+      const expected = `Valid content and ${"Loop ".repeat(15)}#loop`;
+      expect(result).toBe(expected);
+    });
+
+    it("should handle multiple independent loops", () => {
+      const registry: SnippetRegistry = new Map([
+        ["main", "#loop1 and #loop2"],
+        ["loop1", "L1 #loop1"],
+        ["loop2", "L2 #loop2"],
+      ]);
+
+      const result = expandHashtags("#main", registry);
+
+      // Each loop expands 15 times independently
+      const expected = `${"L1 ".repeat(15)}#loop1 and ${"L2 ".repeat(15)}#loop2`;
+      expect(result).toBe(expected);
+    });
+
+    it("should handle nested loops", () => {
+      const registry: SnippetRegistry = new Map([
+        ["outer", "Outer #inner"],
+        ["inner", "Inner #outer and #self"],
+        ["self", "Self #self"],
+      ]);
+
+      const result = expandHashtags("#outer", registry);
+
+      // Complex nested loop - outer/inner cycle 15 times, plus self cycles
+      // This is complex expansion behavior, just verify it doesn't hang
+      expect(result).toContain("Outer");
+      expect(result).toContain("Inner");
+      expect(result).toContain("#outer");
+      expect(result).toContain("#self");
+    });
+
+    it("should handle diamond pattern (same snippet reached via multiple paths)", () => {
+      const registry: SnippetRegistry = new Map([
+        ["top", "#left #right"],
+        ["left", "Left #bottom"],
+        ["right", "Right #bottom"],
+        ["bottom", "Bottom"],
+      ]);
+
+      const result = expandHashtags("#top", registry);
+
+      // Diamond: top -> left -> bottom, top -> right -> bottom
+      expect(result).toBe("Left Bottom Right Bottom");
+    });
+
+    it("should handle loop after valid expansion", () => {
+      const registry: SnippetRegistry = new Map([
+        ["a", "#b #c"],
+        ["b", "Valid B"],
+        ["c", "#d"],
+        ["d", "#c"], // Loop back
+      ]);
+
+      const result = expandHashtags("#a", registry);
+
+      expect(result).toBe("Valid B #c");
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should handle empty registry", () => {
+      const registry: SnippetRegistry = new Map();
+
+      const result = expandHashtags("#anything", registry);
+
+      expect(result).toBe("#anything");
+    });
+
+    it("should handle snippet with empty content", () => {
+      const registry: SnippetRegistry = new Map([["empty", ""]]);
+
+      const result = expandHashtags("Before #empty After", registry);
+
+      expect(result).toBe("Before  After");
+    });
+
+    it("should handle snippet containing only hashtags", () => {
+      const registry: SnippetRegistry = new Map([
+        ["only-refs", "#a #b"],
+        ["a", "A"],
+        ["b", "B"],
+      ]);
+
+      const result = expandHashtags("#only-refs", registry);
+
+      expect(result).toBe("A B");
+    });
+
+    it("should handle hashtags at start, middle, and end", () => {
+      const registry: SnippetRegistry = new Map([
+        ["start", "Start"],
+        ["middle", "Middle"],
+        ["end", "End"],
+      ]);
+
+      const result = expandHashtags("#start text #middle text #end", registry);
+
+      expect(result).toBe("Start text Middle text End");
+    });
+
+    it("should handle consecutive hashtags", () => {
+      const registry: SnippetRegistry = new Map([
+        ["a", "A"],
+        ["b", "B"],
+        ["c", "C"],
+      ]);
+
+      const result = expandHashtags("#a#b#c", registry);
+
+      expect(result).toBe("ABC");
+    });
+
+    it("should handle hashtags with hyphens and underscores", () => {
+      const registry: SnippetRegistry = new Map([
+        ["my-snippet", "Hyphenated"],
+        ["my_snippet", "Underscored"],
+        ["my-complex_name", "Mixed"],
+      ]);
+
+      const result = expandHashtags("#my-snippet #my_snippet #my-complex_name", registry);
+
+      expect(result).toBe("Hyphenated Underscored Mixed");
+    });
+
+    it("should handle hashtags with numbers", () => {
+      const registry: SnippetRegistry = new Map([
+        ["test123", "Test with numbers"],
+        ["123test", "Numbers first"],
+      ]);
+
+      const result = expandHashtags("#test123 #123test", registry);
+
+      expect(result).toBe("Test with numbers Numbers first");
+    });
+
+    it("should not expand hashtags in URLs", () => {
+      const registry: SnippetRegistry = new Map([["issue", "ISSUE"]]);
+
+      // Note: The current implementation WILL expand #issue in URLs
+      // This test documents current behavior
+      const result = expandHashtags("See https://github.com/user/repo/issues/#issue", registry);
+
+      expect(result).toBe("See https://github.com/user/repo/issues/ISSUE");
+    });
+
+    it("should handle multiline content", () => {
+      const registry: SnippetRegistry = new Map([["multiline", "Line 1\nLine 2\nLine 3"]]);
+
+      const result = expandHashtags("Start\n#multiline\nEnd", registry);
+
+      expect(result).toBe("Start\nLine 1\nLine 2\nLine 3\nEnd");
+    });
+
+    it("should handle nested multiline content", () => {
+      const registry: SnippetRegistry = new Map([
+        ["outer", "Outer start\n#inner\nOuter end"],
+        ["inner", "Inner line 1\nInner line 2"],
+      ]);
+
+      const result = expandHashtags("#outer", registry);
+
+      expect(result).toBe("Outer start\nInner line 1\nInner line 2\nOuter end");
+    });
+  });
+
+  describe("Real-world scenarios", () => {
+    it("should expand code review template with nested snippets", () => {
+      const registry: SnippetRegistry = new Map([
+        ["review", "Code Review Checklist:\n#security\n#performance\n#tests"],
+        ["security", "- Check for SQL injection\n- Validate input"],
+        ["performance", "- Check for N+1 queries\n- Review algorithm complexity"],
+        ["tests", "- Unit tests present\n- Edge cases covered"],
+      ]);
+
+      const result = expandHashtags("#review", registry);
+
+      expect(result).toContain("Code Review Checklist:");
+      expect(result).toContain("Check for SQL injection");
+      expect(result).toContain("Check for N+1 queries");
+      expect(result).toContain("Unit tests present");
+    });
+
+    it("should expand documentation template with shared components", () => {
+      const registry: SnippetRegistry = new Map([
+        ["doc", "# Documentation\n#header\n#body\n#footer"],
+        ["header", "Author: #author\nDate: 2024-01-01"],
+        ["author", "John Doe"],
+        ["body", "Main content here"],
+        ["footer", "Contact: #author"],
+      ]);
+
+      const result = expandHashtags("#doc", registry);
+
+      // #author should be expanded in both header and footer
+      expect(result).toContain("Author: John Doe");
+      expect(result).toContain("Contact: John Doe");
+    });
+
+    it("should handle instruction composition", () => {
+      const registry: SnippetRegistry = new Map([
+        ["careful", "Think step by step. #verify"],
+        ["verify", "Double-check your work."],
+        ["complete", "Be thorough. #careful"],
+      ]);
+
+      const result = expandHashtags("Instructions: #complete", registry);
+
+      expect(result).toBe("Instructions: Be thorough. Think step by step. Double-check your work.");
+    });
+  });
+
+  describe("Performance and stress tests", () => {
+    it("should handle deep nesting without stack overflow", () => {
+      const registry: SnippetRegistry = new Map();
+      const depth = 50;
+
+      // Create a chain: level0 -> level1 -> level2 -> ... -> level49 -> "End"
+      for (let i = 0; i < depth - 1; i++) {
+        registry.set(`level${i}`, `L${i} #level${i + 1}`);
+      }
+      registry.set(`level${depth - 1}`, "End");
+
+      const result = expandHashtags("#level0", registry);
+
+      expect(result).toContain("L0");
+      expect(result).toContain("End");
+      expect(result.split(" ").length).toBe(depth);
+    });
+
+    it("should handle many snippets in one text", () => {
+      const registry: SnippetRegistry = new Map();
+      const count = 100;
+
+      for (let i = 0; i < count; i++) {
+        registry.set(`snippet${i}`, `Content${i}`);
+      }
+
+      const hashtags = Array.from({ length: count }, (_, i) => `#snippet${i}`).join(" ");
+      const result = expandHashtags(hashtags, registry);
+
+      expect(result.split(" ").length).toBe(count);
+      expect(result).toContain("Content0");
+      expect(result).toContain(`Content${count - 1}`);
+    });
+
+    it("should handle wide branching (many children)", () => {
+      const registry: SnippetRegistry = new Map();
+      const branches = 20;
+
+      const children = Array.from({ length: branches }, (_, i) => `#child${i}`).join(" ");
+      registry.set("parent", children);
+
+      for (let i = 0; i < branches; i++) {
+        registry.set(`child${i}`, `Child${i}`);
+      }
+
+      const result = expandHashtags("#parent", registry);
+
+      for (let i = 0; i < branches; i++) {
+        expect(result).toContain(`Child${i}`);
+      }
+    });
+  });
+});

package/src/expander.ts

@@ -1,57 +1,67 @@
-import type { SnippetRegistry } from "./types.js"
-import { PATTERNS } from "./constants.js"
+import { PATTERNS } from "./constants.js";
+import { logger } from "./logger.js";
+import type { SnippetRegistry } from "./types.js";
+
+/**
+ * Maximum number of times a snippet can be expanded to prevent infinite loops
+ */
+const MAX_EXPANSION_COUNT = 15;
 
 /**
  * Expands hashtags in text recursively with loop detection
- * 
+ *
  * @param text - The text containing hashtags to expand
  * @param registry - The snippet registry to look up hashtags
- * @param visited - Set of already-visited snippet keys (for loop detection)
+ * @param expansionCounts - Map tracking how many times each snippet has been expanded
  * @returns The text with all hashtags expanded
  */
 export function expandHashtags(
   text: string,
   registry: SnippetRegistry,
-  visited = new Set<string>()
+  expansionCounts = new Map<string, number>(),
 ): string {
-  let expanded = text
-  let hasChanges = true
-  
+  let expanded = text;
+  let hasChanges = true;
+
   // Keep expanding until no more hashtags are found
   while (hasChanges) {
-    hasChanges = false
-    
+    const previous = expanded;
+    let loopDetected = false;
+
     // Reset regex state (global flag requires this)
-    PATTERNS.HASHTAG.lastIndex = 0
-    
+    PATTERNS.HASHTAG.lastIndex = 0;
+
     expanded = expanded.replace(PATTERNS.HASHTAG, (match, name) => {
-      const key = name.toLowerCase()
-      
-      // Check if we've already expanded this snippet in the current chain
-      if (visited.has(key)) {
-        // Loop detected! Leave the hashtag unchanged to prevent infinite recursion
-        return match
-      }
-      
-      const content = registry.get(key)
-      if (!content) {
+      const key = name.toLowerCase();
+
+      const content = registry.get(key);
+      if (content === undefined) {
         // Unknown snippet - leave as-is
-        return match
+        return match;
       }
-      
-      // Mark this snippet as visited and expand it
-      visited.add(key)
-      hasChanges = true
-      
+
+      // Track expansion count to prevent infinite loops
+      const count = (expansionCounts.get(key) || 0) + 1;
+      if (count > MAX_EXPANSION_COUNT) {
+        // Loop detected! Leave the hashtag as-is and stop expanding
+        logger.warn(
+          `Loop detected: snippet '#${key}' expanded ${count} times (max: ${MAX_EXPANSION_COUNT})`,
+        );
+        loopDetected = true;
+        return match; // Leave as-is instead of error message
+      }
+
+      expansionCounts.set(key, count);
+
       // Recursively expand any hashtags in the snippet content
-      const result = expandHashtags(content, registry, new Set(visited))
-      
-      // Remove from visited set after expansion (allows reuse in different branches)
-      visited.delete(key)
-      
-      return result
-    })
+      const result = expandHashtags(content, registry, expansionCounts);
+
+      return result;
+    });
+
+    // Only continue if the text actually changed AND no loop was detected
+    hasChanges = expanded !== previous && !loopDetected;
   }
-  
-  return expanded
+
+  return expanded;
 }