opencode-snippets 1.3.0 → 1.4.1

package/README.md

@@ -190,6 +190,48 @@ I reference I reference I reference ... (15 times) ... I reference #self
 
 This generous limit supports complex snippet hierarchies while preventing infinite loops.
 
+### Prepend and Append Blocks
+
+For long reference material that would break your writing flow, use `<append>` blocks to place content at the end of your message:
+
+```markdown
+---
+aliases: jira-mcp
+---
+Jira MCP server
+<append>
+## Jira MCP Usage
+
+Use these custom field mappings when creating issues:
+- customfield_16570 => Acceptance Criteria
+- customfield_11401 => Team
+</append>
+```
+
+**Input:** `Create a bug ticket in #jira-mcp about the memory leak`
+
+**Output:**
+```
+Create a bug ticket in Jira MCP server about the memory leak
+
+## Jira MCP Usage
+
+Use these custom field mappings when creating issues:
+- customfield_16570 => Acceptance Criteria
+- customfield_11401 => Team
+```
+
+Write naturally—reference what you need mid-sentence—and the context follows at the bottom.
+
+Use `<prepend>` for content that should appear at the top of your message. Multiple blocks of the same type are concatenated in order of appearance.
+
+**Block behavior:**
+- Content outside `<prepend>`/`<append>` blocks replaces the hashtag inline
+- If a snippet has only blocks (no inline content), the hashtag is simply removed
+- Blocks from nested snippets are collected and assembled in the final message
+- Unclosed tags are handled leniently (rest of content becomes the block)
+- Nested blocks are not allowed—the hashtag is left unchanged
+
 ## Example Snippets
 
 ### `~/.config/opencode/snippet/context.md`

package/index.ts

@@ -1,6 +1,6 @@
 import type { Plugin } from "@opencode-ai/plugin";
 import { createCommandExecuteHandler } from "./src/commands.js";
-import { expandHashtags } from "./src/expander.js";
+import { assembleMessage, expandHashtags } from "./src/expander.js";
 import { loadSnippets } from "./src/loader.js";
 import { logger } from "./src/logger.js";
 import { executeShellCommands, type ShellContext } from "./src/shell.js";
@@ -53,7 +53,8 @@ export const SnippetsPlugin: Plugin = async (ctx) => {
         if (part.type === "text" && part.text) {
           // 1. Expand hashtags recursively with loop detection
           const expandStart = performance.now();
-          part.text = expandHashtags(part.text, snippets);
+          const expansionResult = expandHashtags(part.text, snippets);
+          part.text = assembleMessage(expansionResult);
           const expandTime = performance.now() - expandStart;
           expandTimeTotal += expandTime;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-snippets",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "Hashtag-based snippet expansion plugin for OpenCode - instant inline text shortcuts",
   "main": "index.ts",
   "type": "module",

package/src/arg-parser.test.ts

@@ -0,0 +1,177 @@
+import { describe, expect, it } from "bun:test";
+import { parseCommandArgs } from "./arg-parser.js";
+
+describe("parseCommandArgs", () => {
+  // Basic splitting
+  describe("basic argument splitting", () => {
+    it("splits simple space-separated args", () => {
+      expect(parseCommandArgs("add test")).toEqual(["add", "test"]);
+    });
+
+    it("handles empty input", () => {
+      expect(parseCommandArgs("")).toEqual([]);
+    });
+
+    it("handles whitespace-only input", () => {
+      expect(parseCommandArgs("   ")).toEqual([]);
+    });
+
+    it("handles multiple spaces between args", () => {
+      expect(parseCommandArgs("add   test")).toEqual(["add", "test"]);
+    });
+
+    it("handles leading and trailing spaces", () => {
+      expect(parseCommandArgs("  add test  ")).toEqual(["add", "test"]);
+    });
+
+    it("handles tabs and mixed whitespace", () => {
+      expect(parseCommandArgs("add\t\ttest")).toEqual(["add", "test"]);
+    });
+  });
+
+  // Double quote handling
+  describe("double quote handling", () => {
+    it("preserves double-quoted strings with spaces", () => {
+      expect(parseCommandArgs('add "hello world"')).toEqual(["add", "hello world"]);
+    });
+
+    it("handles single quote inside double quotes", () => {
+      // THE MAIN BUG - apostrophe in description
+      expect(parseCommandArgs('--desc="don\'t do this"')).toEqual(["--desc=don't do this"]);
+    });
+
+    it("handles empty double-quoted string", () => {
+      expect(parseCommandArgs('add ""')).toEqual(["add", ""]);
+    });
+
+    it("handles double-quoted string at start", () => {
+      expect(parseCommandArgs('"hello world" test')).toEqual(["hello world", "test"]);
+    });
+
+    it("handles multiple double-quoted strings", () => {
+      expect(parseCommandArgs('"first" "second"')).toEqual(["first", "second"]);
+    });
+  });
+
+  // Single quote handling
+  describe("single quote handling", () => {
+    it("preserves single-quoted strings with spaces", () => {
+      expect(parseCommandArgs("add 'hello world'")).toEqual(["add", "hello world"]);
+    });
+
+    it("handles double quote inside single quotes", () => {
+      expect(parseCommandArgs("--desc='say \"hello\"'")).toEqual(['--desc=say "hello"']);
+    });
+
+    it("handles empty single-quoted string", () => {
+      expect(parseCommandArgs("add ''")).toEqual(["add", ""]);
+    });
+  });
+
+  // --key=value syntax
+  describe("--key=value syntax", () => {
+    it("handles --key=value without quotes", () => {
+      expect(parseCommandArgs("--desc=hello")).toEqual(["--desc=hello"]);
+    });
+
+    it('handles --key="value" with quotes stripped from value', () => {
+      expect(parseCommandArgs('--desc="hello world"')).toEqual(["--desc=hello world"]);
+    });
+
+    it("handles --key='value' with quotes stripped from value", () => {
+      expect(parseCommandArgs("--key='hello world'")).toEqual(["--key=hello world"]);
+    });
+
+    it("handles --key=value with special characters", () => {
+      expect(parseCommandArgs("--desc=hello,world")).toEqual(["--desc=hello,world"]);
+    });
+
+    it("preserves = inside quoted value", () => {
+      expect(parseCommandArgs('--desc="a=b"')).toEqual(["--desc=a=b"]);
+    });
+  });
+
+  // Multiline content (critical for snippet bodies)
+  describe("multiline content", () => {
+    it("handles multiline content in double quotes", () => {
+      expect(parseCommandArgs('add test "line1\nline2\nline3"')).toEqual([
+        "add",
+        "test",
+        "line1\nline2\nline3",
+      ]);
+    });
+
+    it("handles multiline content in single quotes", () => {
+      expect(parseCommandArgs("add test 'line1\nline2'")).toEqual(["add", "test", "line1\nline2"]);
+    });
+
+    it("handles multiline content with --key=value syntax", () => {
+      expect(parseCommandArgs('--desc="line1\nline2"')).toEqual(["--desc=line1\nline2"]);
+    });
+
+    it("preserves indentation in multiline content", () => {
+      const input = 'add test "line1\n  indented\n    more indented"';
+      expect(parseCommandArgs(input)).toEqual([
+        "add",
+        "test",
+        "line1\n  indented\n    more indented",
+      ]);
+    });
+  });
+
+  // Mixed scenarios
+  describe("mixed scenarios", () => {
+    it("handles mixed quoted and unquoted args", () => {
+      expect(parseCommandArgs('add test "hello world" --project')).toEqual([
+        "add",
+        "test",
+        "hello world",
+        "--project",
+      ]);
+    });
+
+    it("handles complex command with all option types", () => {
+      const input = 'add mysnippet "content here" --aliases=a,b --desc="don\'t forget" --project';
+      expect(parseCommandArgs(input)).toEqual([
+        "add",
+        "mysnippet",
+        "content here",
+        "--aliases=a,b",
+        "--desc=don't forget",
+        "--project",
+      ]);
+    });
+
+    it("handles --key value syntax (space-separated)", () => {
+      expect(parseCommandArgs("--desc hello")).toEqual(["--desc", "hello"]);
+    });
+
+    it("handles --key followed by quoted value", () => {
+      expect(parseCommandArgs('--desc "hello world"')).toEqual(["--desc", "hello world"]);
+    });
+  });
+
+  // Edge cases
+  describe("edge cases", () => {
+    it("handles unclosed double quote by including rest of string", () => {
+      // Graceful handling: treat unclosed quote as extending to end
+      expect(parseCommandArgs('add "unclosed')).toEqual(["add", "unclosed"]);
+    });
+
+    it("handles unclosed single quote by including rest of string", () => {
+      expect(parseCommandArgs("add 'unclosed")).toEqual(["add", "unclosed"]);
+    });
+
+    it("handles backslash-escaped quotes inside double quotes", () => {
+      expect(parseCommandArgs('--desc="say \\"hello\\""')).toEqual(['--desc=say "hello"']);
+    });
+
+    it("handles backslash-escaped quotes inside single quotes", () => {
+      expect(parseCommandArgs("--desc='it\\'s fine'")).toEqual(["--desc=it's fine"]);
+    });
+
+    it("handles literal backslash", () => {
+      expect(parseCommandArgs('--path="C:\\\\Users"')).toEqual(["--path=C:\\Users"]);
+    });
+  });
+});

package/src/arg-parser.ts

@@ -0,0 +1,87 @@
+/**
+ * Shell-like argument parser that handles quoted strings correctly.
+ *
+ * Supports:
+ * - Space-separated arguments
+ * - Double-quoted strings (preserves spaces, allows single quotes inside)
+ * - Single-quoted strings (preserves spaces, allows double quotes inside)
+ * - --key=value syntax with quoted values
+ * - Multiline content inside quotes
+ * - Backslash escapes for quotes inside quoted strings
+ *
+ * @param input - The raw argument string to parse
+ * @returns Array of parsed arguments with quotes stripped
+ */
+export function parseCommandArgs(input: string): string[] {
+  const args: string[] = [];
+  let current = "";
+  let state: "normal" | "double" | "single" = "normal";
+  let hasQuotedContent = false; // Track if we've entered a quoted section
+  let i = 0;
+
+  while (i < input.length) {
+    const char = input[i];
+
+    if (state === "normal") {
+      if (char === " " || char === "\t") {
+        // Whitespace in normal mode: finish current token
+        if (current.length > 0 || hasQuotedContent) {
+          args.push(current);
+          current = "";
+          hasQuotedContent = false;
+        }
+      } else if (char === '"') {
+        // Enter double-quote mode
+        state = "double";
+        hasQuotedContent = true;
+      } else if (char === "'") {
+        // Enter single-quote mode
+        state = "single";
+        hasQuotedContent = true;
+      } else {
+        current += char;
+      }
+    } else if (state === "double") {
+      if (char === "\\") {
+        // Check for escape sequences
+        const next = input[i + 1];
+        if (next === '"' || next === "\\") {
+          current += next;
+          i++; // Skip the escaped character
+        } else {
+          current += char;
+        }
+      } else if (char === '"') {
+        // Exit double-quote mode
+        state = "normal";
+      } else {
+        current += char;
+      }
+    } else if (state === "single") {
+      if (char === "\\") {
+        // Check for escape sequences
+        const next = input[i + 1];
+        if (next === "'" || next === "\\") {
+          current += next;
+          i++; // Skip the escaped character
+        } else {
+          current += char;
+        }
+      } else if (char === "'") {
+        // Exit single-quote mode
+        state = "normal";
+      } else {
+        current += char;
+      }
+    }
+
+    i++;
+  }
+
+  // Handle any remaining content (including unclosed quotes or empty quoted strings)
+  if (current.length > 0 || hasQuotedContent) {
+    args.push(current);
+  }
+
+  return args;
+}

package/src/commands.test.ts

@@ -0,0 +1,188 @@
+import { describe, expect, it } from "bun:test";
+import { parseAddOptions } from "./commands.js";
+
+describe("parseAddOptions", () => {
+  // Alias variations - all 4 must work per PR #13 requirements
+  describe("alias parameter variations", () => {
+    it("parses --alias=a,b", () => {
+      expect(parseAddOptions(["--alias=a,b"])).toEqual({
+        aliases: ["a", "b"],
+        description: undefined,
+        isProject: false,
+      });
+    });
+
+    it("parses --alias a,b (space-separated)", () => {
+      expect(parseAddOptions(["--alias", "a,b"])).toEqual({
+        aliases: ["a", "b"],
+        description: undefined,
+        isProject: false,
+      });
+    });
+
+    it("parses --aliases=a,b", () => {
+      expect(parseAddOptions(["--aliases=a,b"])).toEqual({
+        aliases: ["a", "b"],
+        description: undefined,
+        isProject: false,
+      });
+    });
+
+    it("parses --aliases a,b (space-separated)", () => {
+      expect(parseAddOptions(["--aliases", "a,b"])).toEqual({
+        aliases: ["a", "b"],
+        description: undefined,
+        isProject: false,
+      });
+    });
+
+    it("parses single alias", () => {
+      expect(parseAddOptions(["--alias=foo"])).toEqual({
+        aliases: ["foo"],
+        description: undefined,
+        isProject: false,
+      });
+    });
+
+    it("handles multiple alias values with spaces", () => {
+      expect(parseAddOptions(["--aliases=hello, world, foo"])).toEqual({
+        aliases: ["hello", "world", "foo"],
+        description: undefined,
+        isProject: false,
+      });
+    });
+  });
+
+  // Description variations - all must work
+  describe("description parameter variations", () => {
+    it("parses --desc=value", () => {
+      expect(parseAddOptions(["--desc=hello"])).toEqual({
+        aliases: [],
+        description: "hello",
+        isProject: false,
+      });
+    });
+
+    it("parses --desc value (space-separated)", () => {
+      expect(parseAddOptions(["--desc", "hello"])).toEqual({
+        aliases: [],
+        description: "hello",
+        isProject: false,
+      });
+    });
+
+    it("parses --desc with apostrophe (main bug)", () => {
+      expect(parseAddOptions(["--desc=don't break"])).toEqual({
+        aliases: [],
+        description: "don't break",
+        isProject: false,
+      });
+    });
+
+    it("parses --description=value", () => {
+      expect(parseAddOptions(["--description=test"])).toEqual({
+        aliases: [],
+        description: "test",
+        isProject: false,
+      });
+    });
+
+    it("parses --description value (space-separated)", () => {
+      expect(parseAddOptions(["--description", "test"])).toEqual({
+        aliases: [],
+        description: "test",
+        isProject: false,
+      });
+    });
+
+    it("parses --desc with multiline content", () => {
+      expect(parseAddOptions(["--desc=line1\nline2"])).toEqual({
+        aliases: [],
+        description: "line1\nline2",
+        isProject: false,
+      });
+    });
+  });
+
+  // Project flag
+  describe("--project flag", () => {
+    it("parses --project flag", () => {
+      expect(parseAddOptions(["--project"])).toEqual({
+        aliases: [],
+        description: undefined,
+        isProject: true,
+      });
+    });
+
+    it("parses --project in any position", () => {
+      expect(parseAddOptions(["--desc=test", "--project"])).toEqual({
+        aliases: [],
+        description: "test",
+        isProject: true,
+      });
+    });
+  });
+
+  // Combined options
+  describe("combined options", () => {
+    it("parses multiple options together", () => {
+      expect(parseAddOptions(["--alias=a,b", "--desc=hello", "--project"])).toEqual({
+        aliases: ["a", "b"],
+        description: "hello",
+        isProject: true,
+      });
+    });
+
+    it("parses all space-separated options together", () => {
+      expect(parseAddOptions(["--alias", "a,b", "--desc", "hello", "--project"])).toEqual({
+        aliases: ["a", "b"],
+        description: "hello",
+        isProject: true,
+      });
+    });
+
+    it("handles mixed = and space syntax", () => {
+      expect(parseAddOptions(["--alias=a,b", "--desc", "hello"])).toEqual({
+        aliases: ["a", "b"],
+        description: "hello",
+        isProject: false,
+      });
+    });
+  });
+
+  // Edge cases
+  describe("edge cases", () => {
+    it("returns defaults for empty args", () => {
+      expect(parseAddOptions([])).toEqual({
+        aliases: [],
+        description: undefined,
+        isProject: false,
+      });
+    });
+
+    it("ignores unknown options", () => {
+      expect(parseAddOptions(["--unknown=value", "--desc=hello"])).toEqual({
+        aliases: [],
+        description: "hello",
+        isProject: false,
+      });
+    });
+
+    it("ignores positional args (non-option)", () => {
+      expect(parseAddOptions(["positional", "--desc=hello"])).toEqual({
+        aliases: [],
+        description: "hello",
+        isProject: false,
+      });
+    });
+
+    it("does not consume value after --project", () => {
+      // --project is a flag, should not consume next arg
+      expect(parseAddOptions(["--project", "--desc=hello"])).toEqual({
+        aliases: [],
+        description: "hello",
+        isProject: true,
+      });
+    });
+  });
+});