refactor: remove unnecessary raw block wrapping from command output

Command imports run in Phase 3 (after LiquidJS template processing),
so there's no need to wrap output in {% raw %} blocks to prevent
template interpretation. This simplifies the code and test assertions.

Author: johnlindquist

src/__snapshots__/snapshot.test.ts.snap

@@ -85,10 +85,8 @@ Process these files accordingly."
 exports[`Snapshot Tests Command substitution executes and inlines command output 1`] = `
 "Current date context:
 
-
 Test command output
 
-
 Please proceed with the task."
 `;
 

src/imports.test.ts

@@ -71,14 +71,14 @@ test("expandImports throws on missing file", async () => {
 test("expandImports executes command inline", async () => {
   const content = "Output: !`echo hello`";
   const result = await expandImports(content, testDir);
-  // Command output is wrapped in {% raw %} to prevent LiquidJS template interpretation
-  expect(result).toBe("Output: {% raw %}\nhello\n{% endraw %}");
+  // Command output is returned directly (Phase 3 runs after LiquidJS)
+  expect(result).toBe("Output: hello");
 });
 
 test("expandImports handles command with arguments", async () => {
   const content = "!`echo one two three`";
   const result = await expandImports(content, testDir);
-  expect(result).toBe("{% raw %}\none two three\n{% endraw %}")
+  expect(result).toBe("one two three");
 });
 
 test("expandImports handles multiple imports", async () => {
@@ -90,7 +90,7 @@ test("expandImports handles multiple imports", async () => {
 test("expandImports handles mixed file and command", async () => {
   const content = "File: @./simple.md Command: !`echo test`";
   const result = await expandImports(content, testDir);
-  expect(result).toBe("File: Hello from simple.md Command: {% raw %}\ntest\n{% endraw %}");
+  expect(result).toBe("File: Hello from simple.md Command: test");
 });
 
 test("expandImports preserves content without imports", async () => {
@@ -525,15 +525,15 @@ describe("template variables in commands", () => {
     expect(result).toContain("piped-content");
   });
 
-  test("protects command output from template interpretation", async () => {
-    // Command outputs {{ foo }} - should be wrapped in {% raw %} and not interpreted
+  test("command output is returned directly (Phase 3 runs after LiquidJS)", async () => {
+    // Command output containing template-like syntax is returned as-is
+    // (no wrapping needed since commands run after template processing)
     const content = "!`echo '{{ output }}'`";
     const result = await expandImports(content, testDir, new Set(), false, {
       templateVars: {},
     });
-    // Output should be wrapped in {% raw %}...{% endraw %}
-    expect(result).toContain("{% raw %}");
-    expect(result).toContain("{% endraw %}");
+    // Output should contain the literal {{ output }} text
+    expect(result).toContain("{{ output }}");
   });
 });
 
@@ -651,7 +651,6 @@ describe("executable code fences", () => {
     const content = '```sh\n#!/bin/bash\necho "hello from bash"\n```';
     const result = await expandImports(content, testDir);
     expect(result).toContain("hello from bash");
-    expect(result).toContain("{% raw %}");
   });
 
   test("executes bun/typescript code fence with shebang", async () => {
@@ -672,13 +671,12 @@ describe("executable code fences", () => {
     await expect(expandImports(content, testDir)).rejects.toThrow("Code fence failed");
   });
 
-  test("code fence output is wrapped in raw block", async () => {
+  test("code fence output is returned directly (Phase 3 runs after LiquidJS)", async () => {
     const content = '```sh\n#!/bin/bash\necho "{{ template syntax }}"\n```';
     const result = await expandImports(content, testDir);
-    // Output should be protected from LiquidJS interpretation
-    expect(result).toContain("{% raw %}");
-    expect(result).toContain("{% endraw %}");
+    // Output returned as-is (no wrapping needed since code fences run after template processing)
     expect(result).toContain("{{ template syntax }}");
+    expect(result).not.toContain("{% raw %}");
   });
 
   test("respects dry-run mode for code fences", async () => {

src/imports.ts

@@ -952,7 +952,7 @@ async function processCommandInline(
   // Improvement #3: Dry-run safety - skip execution if in dry-run mode
   if (importCtx?.dryRun) {
     console.error(`[imports] Dry-run: Skipping execution of '${actualCommand}'`);
-    return `{% raw %}\n[Dry Run: Command "${actualCommand}" not executed]\n{% endraw %}`;
+    return `[Dry Run: Command "${actualCommand}" not executed]`;
   }
 
   // Use importCtx.env if provided, otherwise fall back to process.env
@@ -1072,12 +1072,7 @@ async function processCommandInline(
         `\n... [Output truncated: ${truncatedChars.toLocaleString()} characters removed]`;
     }
 
-    // Improvement #7: Sanitize LiquidJS tags - escape {% endraw %} in output
-    // to prevent breaking out of the raw block
-    if (output) {
-      const safeOutput = output.replace(/\{% endraw %\}/g, "{% endraw %}{{ '{% endraw %}' }}{% raw %}");
-      return `{% raw %}\n${safeOutput}\n{% endraw %}`;
-    }
+    // Command output is processed after LiquidJS (Phase 3), so no template escaping needed
     return output;
   } catch (err) {
     // Include more context in error messages
@@ -1104,7 +1099,7 @@ async function processExecutableCodeFence(
   console.error(`[imports] Executing code fence (${language}): ${shebang}`);
 
   if (importCtx?.dryRun) {
-    return `{% raw %}\n[Dry Run: Code fence not executed]\n{% endraw %}`;
+    return "[Dry Run: Code fence not executed]";
   }
 
   const ext = { ts: 'ts', js: 'js', py: 'py', sh: 'sh', bash: 'sh' }[language] ?? language;
@@ -1130,12 +1125,8 @@ async function processExecutableCodeFence(
       throw new Error(`Code fence failed (Exit ${proc.exitCode}): ${errorOutput}`);
     }
 
-    const output = (stdout + stderr).trim().replace(ANSI_ESCAPE_REGEX, '');
-    if (output) {
-      const safe = output.replace(/\{% endraw %\}/g, "{% endraw %}{{ '{% endraw %}' }}{% raw %}");
-      return `{% raw %}\n${safe}\n{% endraw %}`;
-    }
-    return output;
+    // Command output is processed after LiquidJS (Phase 3), so no template escaping needed
+    return (stdout + stderr).trim().replace(ANSI_ESCAPE_REGEX, '');
   } finally {
     try { await unlink(tmpFile); } catch {}
   }