@aladac/hu 0.1.0-a1 → 0.1.0-a2

package/tests/lib/escaping.test.ts

@@ -0,0 +1,257 @@
+/**
+ * Escaping Regression Tests
+ * 
+ * These tests verify that special characters are handled correctly
+ * through the entire data pipeline. Each test documents the specific
+ * bug it prevents.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { writeTempJson, readTempJson } from '../../src/lib/hook-io.ts';
+import { readJsonlFileSync, appendToJsonl } from '../../src/lib/jsonl.ts';
+
+describe('escaping', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hu-escaping-test-'));
+  });
+
+  afterEach(() => {
+    try {
+      fs.rmSync(tempDir, { recursive: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('quote characters', () => {
+    // Bug: Unescaped quotes break JSON parsing
+    it('handles double quotes in strings', () => {
+      const data = { message: 'He said "hello world"' };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+
+    // Bug: Single quotes can cause issues in shell contexts
+    it('handles single quotes in strings', () => {
+      const data = { message: "It's working" };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+
+    // Bug: Mixed quotes break naive escaping
+    it('handles mixed quotes', () => {
+      const data = { message: `He said "it's fine"` };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+  });
+
+  describe('backslashes', () => {
+    // Bug: Single backslash gets consumed as escape
+    it('handles single backslash', () => {
+      const data = { path: 'C:\\Users\\test' };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+
+    // Bug: Double backslash collapses to single
+    it('handles double backslash', () => {
+      const data = { regex: '\\\\n' };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+
+    // Bug: Backslash before quote is problematic
+    it('handles backslash before quote', () => {
+      const data = { value: 'escaped\\"quote' };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+  });
+
+  describe('newlines and whitespace', () => {
+    // Bug: Literal newlines break single-line JSON
+    it('handles newline characters', () => {
+      const data = { text: 'line1\nline2\nline3' };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+
+    // Bug: Tabs can be confused with field separators
+    it('handles tab characters', () => {
+      const data = { text: 'col1\tcol2\tcol3' };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+
+    // Bug: Carriage return causes issues on different platforms
+    it('handles carriage return', () => {
+      const data = { text: 'windows\r\nline ending' };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+  });
+
+  describe('shell special characters', () => {
+    // Bug: Dollar sign triggers variable expansion
+    it('handles dollar sign', () => {
+      const data = { cost: '$100', var: '$HOME' };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+
+    // Bug: Backticks trigger command substitution
+    it('handles backticks', () => {
+      const data = { code: '`npm install`' };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+
+    // Bug: $(cmd) triggers command substitution
+    it('handles $() syntax', () => {
+      const data = { cmd: '$(whoami)' };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+
+    // Bug: Exclamation can trigger history expansion in some shells
+    it('handles exclamation mark', () => {
+      const data = { message: 'Hello!' };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+
+    // Bug: Semicolon can terminate commands
+    it('handles semicolon', () => {
+      const data = { cmd: 'cmd1; cmd2' };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+
+    // Bug: Pipe can redirect output
+    it('handles pipe character', () => {
+      const data = { cmd: 'cat file | grep pattern' };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+
+    // Bug: Ampersand can background or chain commands
+    it('handles ampersand', () => {
+      const data = { cmd: 'cmd1 && cmd2', bg: 'cmd &' };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+  });
+
+  describe('nested JSON', () => {
+    // Bug: JSON inside JSON needs double escaping
+    it('handles JSON string as value', () => {
+      const inner = { nested: true, value: 'test' };
+      const data = { json_string: JSON.stringify(inner) };
+      const filePath = writeTempJson(data);
+      const read = readTempJson<{ json_string: string }>(filePath);
+      expect(read.json_string).toBe(JSON.stringify(inner));
+      expect(JSON.parse(read.json_string)).toEqual(inner);
+    });
+
+    // Bug: Deeply nested JSON with special chars
+    it('handles deeply nested JSON with special characters', () => {
+      const inner = { 
+        message: 'He said "hello"',
+        path: 'C:\\test',
+        cmd: '$(rm -rf /)',
+      };
+      const data = { 
+        level1: JSON.stringify({ 
+          level2: JSON.stringify(inner) 
+        }) 
+      };
+      const filePath = writeTempJson(data);
+      const read = readTempJson<typeof data>(filePath);
+      
+      const l1 = JSON.parse(read.level1);
+      const l2 = JSON.parse(l1.level2);
+      expect(l2).toEqual(inner);
+    });
+  });
+
+  describe('JSONL specific', () => {
+    // Bug: Newlines in content break JSONL line separation
+    it('preserves newlines in JSONL content', () => {
+      const jsonlPath = path.join(tempDir, 'test.jsonl');
+      
+      appendToJsonl(jsonlPath, { content: 'line1\nline2' });
+      appendToJsonl(jsonlPath, { content: 'another\nmultiline' });
+      
+      const entries = readJsonlFileSync<{ content: string }>(jsonlPath);
+      expect(entries).toHaveLength(2);
+      expect(entries[0].content).toBe('line1\nline2');
+      expect(entries[1].content).toBe('another\nmultiline');
+    });
+
+    // Bug: Quotes in JSONL can break parsing
+    it('handles quotes in JSONL values', () => {
+      const jsonlPath = path.join(tempDir, 'quotes.jsonl');
+      
+      appendToJsonl(jsonlPath, { message: 'said "hello"' });
+      
+      const entries = readJsonlFileSync<{ message: string }>(jsonlPath);
+      expect(entries[0].message).toBe('said "hello"');
+    });
+  });
+
+  describe('unicode edge cases', () => {
+    // Bug: Some unicode chars can cause encoding issues
+    it('handles zero-width characters', () => {
+      const data = { text: 'invisible\u200Bchar' };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+
+    // Bug: BOM can cause parsing issues
+    it('handles byte order mark', () => {
+      const data = { text: '\uFEFFwith BOM' };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+
+    // Bug: Combining characters can affect string length
+    it('handles combining characters', () => {
+      const data = { text: 'e\u0301' }; // é as e + combining accent
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+
+    // Bug: Emoji sequences can be multi-codepoint
+    it('handles complex emoji sequences', () => {
+      const data = { emoji: '👨‍👩‍👧‍👦' }; // family emoji (multiple codepoints)
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+    });
+  });
+});

package/tests/lib/hook-io.test.ts

@@ -0,0 +1,151 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  writeTempJson,
+  readTempJson,
+  deleteTempFile,
+  cleanupTempFiles,
+  hooksEnabled,
+} from '../../src/lib/hook-io.ts';
+
+describe('hook-io', () => {
+  let tempDir: string;
+  
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hu-hook-test-'));
+  });
+  
+  afterEach(() => {
+    // Clean up test directory
+    try {
+      fs.rmSync(tempDir, { recursive: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('writeTempJson / readTempJson', () => {
+    it('roundtrips simple objects', () => {
+      const data = { foo: 'bar', count: 42 };
+      const filePath = writeTempJson(data);
+      expect(fs.existsSync(filePath)).toBe(true);
+      
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+      
+      deleteTempFile(filePath);
+    });
+
+    it('preserves unicode characters', () => {
+      const data = {
+        emoji: '🎉🚀',
+        cjk: '日本語テスト',
+        arabic: 'مرحبا',
+        mixed: 'Hello 世界 🌍',
+      };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+      
+      deleteTempFile(filePath);
+    });
+
+    it('handles special characters in strings', () => {
+      const data = {
+        quotes: 'He said "hello"',
+        backslashes: 'path\\to\\file',
+        newlines: 'line1\nline2\nline3',
+        tabs: 'col1\tcol2\tcol3',
+        dollar: '$HOME/path',
+        backticks: '`command`',
+      };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+      
+      deleteTempFile(filePath);
+    });
+
+    it('handles nested objects with escaped strings', () => {
+      const data = {
+        outer: {
+          inner: {
+            value: 'nested "quoted" value',
+            array: ['item1', 'item\nwith\nnewlines'],
+          },
+        },
+        json_in_json: JSON.stringify({ nested: true }),
+      };
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+      
+      deleteTempFile(filePath);
+    });
+
+    it('generates unique file names', () => {
+      const paths = new Set<string>();
+      
+      for (let i = 0; i < 100; i++) {
+        const filePath = writeTempJson({ index: i });
+        expect(paths.has(filePath)).toBe(false);
+        paths.add(filePath);
+      }
+      
+      // Clean up
+      for (const p of paths) {
+        deleteTempFile(p);
+      }
+    });
+
+    it('handles arrays', () => {
+      const data = [1, 'two', { three: 3 }, [4, 5]];
+      const filePath = writeTempJson(data);
+      const read = readTempJson(filePath);
+      expect(read).toEqual(data);
+      
+      deleteTempFile(filePath);
+    });
+
+    it('handles null and undefined values', () => {
+      const data = { nullVal: null, undef: undefined, empty: '' };
+      const filePath = writeTempJson(data);
+      const read = readTempJson<Record<string, unknown>>(filePath);
+      expect(read.nullVal).toBe(null);
+      expect(read.undef).toBeUndefined();
+      expect(read.empty).toBe('');
+      
+      deleteTempFile(filePath);
+    });
+  });
+
+  describe('deleteTempFile', () => {
+    it('deletes existing file', () => {
+      const filePath = writeTempJson({ test: true });
+      expect(fs.existsSync(filePath)).toBe(true);
+      
+      deleteTempFile(filePath);
+      expect(fs.existsSync(filePath)).toBe(false);
+    });
+
+    it('does not throw on non-existent file', () => {
+      expect(() => deleteTempFile('/nonexistent/path.json')).not.toThrow();
+    });
+  });
+
+  describe('hooksEnabled', () => {
+    it('returns a boolean', () => {
+      const enabled = hooksEnabled();
+      expect(typeof enabled).toBe('boolean');
+    });
+  });
+
+  describe('cleanupTempFiles', () => {
+    it('returns number of cleaned files', () => {
+      const cleaned = cleanupTempFiles();
+      expect(typeof cleaned).toBe('number');
+    });
+  });
+});

package/tests/lib/jsonl.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  parseJsonl,
+  readJsonlFile,
+  readJsonlFileSync,
+  appendToJsonl,
+  writeJsonlFile,
+} from '../../src/lib/jsonl.ts';
+
+describe('jsonl', () => {
+  const testDir = path.join(os.tmpdir(), `hu-jsonl-test-${process.pid}`);
+  
+  beforeEach(() => {
+    if (!fs.existsSync(testDir)) {
+      fs.mkdirSync(testDir, { recursive: true });
+    }
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true });
+    }
+  });
+
+  describe('readJsonlFileSync', () => {
+    it('parses valid JSONL', () => {
+      const filePath = path.join(testDir, 'valid.jsonl');
+      fs.writeFileSync(filePath, '{"a":1}\n{"b":2}\n{"c":3}\n');
+
+      const result = readJsonlFileSync<{ a?: number; b?: number; c?: number }>(filePath);
+      expect(result).toEqual([{ a: 1 }, { b: 2 }, { c: 3 }]);
+    });
+
+    it('handles empty file', () => {
+      const filePath = path.join(testDir, 'empty.jsonl');
+      fs.writeFileSync(filePath, '');
+
+      const result = readJsonlFileSync(filePath);
+      expect(result).toEqual([]);
+    });
+
+    it('handles non-existent file', () => {
+      const result = readJsonlFileSync(path.join(testDir, 'nonexistent.jsonl'));
+      expect(result).toEqual([]);
+    });
+
+    it('skips empty lines', () => {
+      const filePath = path.join(testDir, 'with-empty.jsonl');
+      fs.writeFileSync(filePath, '{"a":1}\n\n{"b":2}\n  \n{"c":3}\n');
+
+      const result = readJsonlFileSync(filePath);
+      expect(result).toHaveLength(3);
+    });
+
+    it('skips malformed lines', () => {
+      const filePath = path.join(testDir, 'malformed.jsonl');
+      fs.writeFileSync(filePath, '{"a":1}\ninvalid json\n{"b":2}\n');
+
+      const result = readJsonlFileSync(filePath);
+      expect(result).toHaveLength(2);
+    });
+
+    it('preserves unicode content', () => {
+      const filePath = path.join(testDir, 'unicode.jsonl');
+      const data = { text: '日本語テスト 🎉 émojis', path: '/путь/к/файлу' };
+      fs.writeFileSync(filePath, JSON.stringify(data) + '\n');
+
+      const result = readJsonlFileSync<typeof data>(filePath);
+      expect(result[0]).toEqual(data);
+    });
+
+    it('handles escaped characters', () => {
+      const filePath = path.join(testDir, 'escaped.jsonl');
+      const data = {
+        quote: 'He said "hello"',
+        newline: 'line1\nline2',
+        tab: 'col1\tcol2',
+        backslash: 'path\\to\\file',
+      };
+      fs.writeFileSync(filePath, JSON.stringify(data) + '\n');
+
+      const result = readJsonlFileSync<typeof data>(filePath);
+      expect(result[0]).toEqual(data);
+    });
+
+    it('handles nested objects', () => {
+      const filePath = path.join(testDir, 'nested.jsonl');
+      const data = {
+        outer: {
+          inner: {
+            value: 42,
+            array: [1, 2, 3],
+          },
+        },
+      };
+      fs.writeFileSync(filePath, JSON.stringify(data) + '\n');
+
+      const result = readJsonlFileSync<typeof data>(filePath);
+      expect(result[0]).toEqual(data);
+    });
+  });
+
+  describe('readJsonlFile (async)', () => {
+    it('parses valid JSONL', async () => {
+      const filePath = path.join(testDir, 'valid-async.jsonl');
+      fs.writeFileSync(filePath, '{"a":1}\n{"b":2}\n{"c":3}\n');
+
+      const result = await readJsonlFile<{ a?: number; b?: number; c?: number }>(filePath);
+      expect(result).toEqual([{ a: 1 }, { b: 2 }, { c: 3 }]);
+    });
+
+    it('handles non-existent file', async () => {
+      const result = await readJsonlFile(path.join(testDir, 'nonexistent.jsonl'));
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('parseJsonl (generator)', () => {
+    it('yields items one by one', async () => {
+      const filePath = path.join(testDir, 'generator.jsonl');
+      fs.writeFileSync(filePath, '{"n":1}\n{"n":2}\n{"n":3}\n');
+
+      const items: { n: number }[] = [];
+      for await (const item of parseJsonl<{ n: number }>(filePath)) {
+        items.push(item);
+      }
+      expect(items).toEqual([{ n: 1 }, { n: 2 }, { n: 3 }]);
+    });
+  });
+
+  describe('writeJsonlFile', () => {
+    it('writes array to JSONL', () => {
+      const filePath = path.join(testDir, 'write.jsonl');
+      const data = [{ a: 1 }, { b: 2 }, { c: 3 }];
+      
+      writeJsonlFile(filePath, data);
+      
+      const result = readJsonlFileSync(filePath);
+      expect(result).toEqual(data);
+    });
+  });
+
+  describe('appendToJsonl', () => {
+    it('appends item to file', () => {
+      const filePath = path.join(testDir, 'append.jsonl');
+      fs.writeFileSync(filePath, '{"a":1}\n');
+      
+      appendToJsonl(filePath, { b: 2 });
+      
+      const result = readJsonlFileSync(filePath);
+      expect(result).toEqual([{ a: 1 }, { b: 2 }]);
+    });
+
+    it('creates file if not exists', () => {
+      const filePath = path.join(testDir, 'new-append.jsonl');
+      
+      appendToJsonl(filePath, { a: 1 });
+      
+      const result = readJsonlFileSync(filePath);
+      expect(result).toEqual([{ a: 1 }]);
+    });
+  });
+});