noslop 0.1.0

package/dist/lib/content.test.js

@@ -0,0 +1,746 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { parseContent, findItem, createDraft, formatDate, sortBySchedule, isNoslopProject, getContentDirs, isValidUrl, updateStatus, updateSchedule, moveToPosts, moveToDrafts, addPublishedUrl, deleteDraft, } from './content.js';
+describe('content.ts', () => {
+    let testDir;
+    beforeEach(() => {
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'noslop-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(testDir, { recursive: true, force: true });
+    });
+    describe('isNoslopProject', () => {
+        it('returns false for empty directory', () => {
+            expect(isNoslopProject(testDir)).toBe(false);
+        });
+        it('returns true if drafts directory exists', () => {
+            fs.mkdirSync(path.join(testDir, 'drafts'));
+            expect(isNoslopProject(testDir)).toBe(true);
+        });
+        it('returns true if posts directory exists', () => {
+            fs.mkdirSync(path.join(testDir, 'posts'));
+            expect(isNoslopProject(testDir)).toBe(true);
+        });
+    });
+    describe('getContentDirs', () => {
+        it('returns correct paths', () => {
+            const dirs = getContentDirs(testDir);
+            expect(dirs.postsDir).toBe(path.join(testDir, 'posts'));
+            expect(dirs.draftsDir).toBe(path.join(testDir, 'drafts'));
+        });
+    });
+    describe('parseContent', () => {
+        it('returns empty array for non-existent directory', () => {
+            const result = parseContent(path.join(testDir, 'nonexistent'), 'D');
+            expect(result).toEqual([]);
+        });
+        it('parses x.md file with all fields', () => {
+            const draftsDir = path.join(testDir, 'drafts');
+            const postDir = path.join(draftsDir, 'test-post');
+            fs.mkdirSync(postDir, { recursive: true });
+            const xContent = `# Test Title
+
+## Post
+\`\`\`
+Hello world content
+\`\`\`
+
+## Status
+ready
+
+## Media
+screenshot.png
+
+## Scheduled
+2026-01-27 09:00
+
+## Posted
+
+
+## Published
+`;
+            fs.writeFileSync(path.join(postDir, 'x.md'), xContent);
+            const result = parseContent(draftsDir, 'D');
+            expect(result).toHaveLength(1);
+            expect(result[0].title).toBe('Test Title');
+            expect(result[0].post).toBe('Hello world content');
+            expect(result[0].status).toBe('ready');
+            expect(result[0].media).toBe('screenshot.png');
+            expect(result[0].scheduledAt).toBe('2026-01-27 09:00');
+            expect(result[0].id).toBe('D001');
+        });
+        it('handles missing optional fields gracefully', () => {
+            const draftsDir = path.join(testDir, 'drafts');
+            const postDir = path.join(draftsDir, 'minimal-post');
+            fs.mkdirSync(postDir, { recursive: true });
+            const xContent = `# Minimal Post
+
+## Post
+\`\`\`
+Just content
+\`\`\`
+`;
+            fs.writeFileSync(path.join(postDir, 'x.md'), xContent);
+            const result = parseContent(draftsDir, 'D');
+            expect(result).toHaveLength(1);
+            expect(result[0].title).toBe('Minimal Post');
+            expect(result[0].status).toBe('draft');
+            expect(result[0].scheduledAt).toBe('');
+        });
+        it('filters out hidden directories', () => {
+            const draftsDir = path.join(testDir, 'drafts');
+            fs.mkdirSync(path.join(draftsDir, '.hidden'), { recursive: true });
+            fs.mkdirSync(path.join(draftsDir, 'visible'), { recursive: true });
+            fs.writeFileSync(path.join(draftsDir, 'visible', 'x.md'), '# Visible\n\n## Post\n```\ntest\n```');
+            const result = parseContent(draftsDir, 'D');
+            expect(result).toHaveLength(1);
+            expect(result[0].folder).toBe('visible');
+        });
+    });
+    describe('createDraft', () => {
+        beforeEach(() => {
+            fs.mkdirSync(path.join(testDir, 'drafts'));
+        });
+        it('creates folder with slugified name', () => {
+            const item = createDraft('My First Post!', testDir);
+            expect(item.folder).toBe('my-first-post');
+            expect(fs.existsSync(item.path)).toBe(true);
+            expect(fs.existsSync(item.xFile)).toBe(true);
+        });
+        it('creates x.md with correct template', () => {
+            const item = createDraft('Test Post', testDir);
+            const content = fs.readFileSync(item.xFile, 'utf-8');
+            expect(content).toContain('# Test Post');
+            expect(content).toContain('## Post');
+            expect(content).toContain('## Status\ndraft');
+        });
+        it('handles special characters in title', () => {
+            const item = createDraft('Hello & Goodbye!!! @#$%', testDir);
+            expect(item.folder).toBe('hello-goodbye');
+            expect(fs.existsSync(item.path)).toBe(true);
+        });
+        it('creates drafts directory if it does not exist', () => {
+            const emptyDir = fs.mkdtempSync(path.join(os.tmpdir(), 'noslop-empty-'));
+            const item = createDraft('New Post', emptyDir);
+            expect(fs.existsSync(path.join(emptyDir, 'drafts'))).toBe(true);
+            expect(fs.existsSync(item.path)).toBe(true);
+            fs.rmSync(emptyDir, { recursive: true, force: true });
+        });
+    });
+    describe('findItem', () => {
+        beforeEach(() => {
+            const draftsDir = path.join(testDir, 'drafts');
+            fs.mkdirSync(path.join(draftsDir, 'monday-motivation'), { recursive: true });
+            fs.writeFileSync(path.join(draftsDir, 'monday-motivation', 'x.md'), '# Monday Motivation\n\n## Post\n```\ncontent\n```');
+        });
+        it('finds by exact folder name', () => {
+            const item = findItem('monday-motivation', testDir);
+            expect(item).not.toBeNull();
+            expect(item?.folder).toBe('monday-motivation');
+        });
+        it('finds by partial folder name', () => {
+            const item = findItem('monday', testDir);
+            expect(item).not.toBeNull();
+            expect(item?.folder).toBe('monday-motivation');
+        });
+        it('finds by ID', () => {
+            const item = findItem('D001', testDir);
+            expect(item).not.toBeNull();
+        });
+        it('finds by lowercase ID', () => {
+            const item = findItem('d001', testDir);
+            expect(item).not.toBeNull();
+        });
+        it('returns null for non-existent item', () => {
+            const item = findItem('nonexistent', testDir);
+            expect(item).toBeNull();
+        });
+    });
+    describe('formatDate', () => {
+        it('formats date correctly', () => {
+            const date = new Date(2026, 0, 27, 9, 5);
+            expect(formatDate(date)).toBe('2026-01-27 09:05');
+        });
+        it('pads single digits', () => {
+            const date = new Date(2026, 0, 5, 8, 3);
+            expect(formatDate(date)).toBe('2026-01-05 08:03');
+        });
+        it('handles midnight', () => {
+            const date = new Date(2026, 11, 31, 0, 0);
+            expect(formatDate(date)).toBe('2026-12-31 00:00');
+        });
+    });
+    describe('isValidUrl', () => {
+        it('returns true for valid http URL', () => {
+            expect(isValidUrl('http://example.com')).toBe(true);
+        });
+        it('returns true for valid https URL', () => {
+            expect(isValidUrl('https://example.com/path?query=value')).toBe(true);
+        });
+        it('returns true for URL with port', () => {
+            expect(isValidUrl('https://example.com:8080/path')).toBe(true);
+        });
+        it('returns false for invalid URL', () => {
+            expect(isValidUrl('not-a-url')).toBe(false);
+        });
+        it('returns false for empty string', () => {
+            expect(isValidUrl('')).toBe(false);
+        });
+        it('returns false for relative path', () => {
+            expect(isValidUrl('/path/to/something')).toBe(false);
+        });
+    });
+    describe('findItem - path traversal protection', () => {
+        beforeEach(() => {
+            const draftsDir = path.join(testDir, 'drafts');
+            fs.mkdirSync(path.join(draftsDir, 'test-post'), { recursive: true });
+            fs.writeFileSync(path.join(draftsDir, 'test-post', 'x.md'), '# Test\n\n## Post\n```\ncontent\n```');
+        });
+        it('throws error for query with ..', () => {
+            expect(() => findItem('../etc/passwd', testDir)).toThrow('path traversal not allowed');
+        });
+        it('throws error for query starting with /', () => {
+            expect(() => findItem('/etc/passwd', testDir)).toThrow('path traversal not allowed');
+        });
+        it('throws error for query with backslash', () => {
+            expect(() => findItem('..\\windows\\system32', testDir)).toThrow('path traversal not allowed');
+        });
+        it('allows normal queries', () => {
+            expect(() => findItem('test-post', testDir)).not.toThrow();
+        });
+    });
+    describe('sortBySchedule', () => {
+        it('sorts by scheduled date ascending', () => {
+            const items = [
+                { scheduledAt: '2026-01-30 09:00' },
+                { scheduledAt: '2026-01-25 09:00' },
+                { scheduledAt: '2026-01-28 09:00' },
+            ];
+            const sorted = sortBySchedule(items);
+            expect(sorted[0].scheduledAt).toBe('2026-01-25 09:00');
+            expect(sorted[1].scheduledAt).toBe('2026-01-28 09:00');
+            expect(sorted[2].scheduledAt).toBe('2026-01-30 09:00');
+        });
+        it('puts unscheduled items at the end', () => {
+            const items = [
+                { scheduledAt: '' },
+                { scheduledAt: '2026-01-25 09:00' },
+            ];
+            const sorted = sortBySchedule(items);
+            expect(sorted[0].scheduledAt).toBe('2026-01-25 09:00');
+            expect(sorted[1].scheduledAt).toBe('');
+        });
+        it('does not mutate original array', () => {
+            const items = [
+                { scheduledAt: '2026-01-30 09:00' },
+                { scheduledAt: '2026-01-25 09:00' },
+            ];
+            const sorted = sortBySchedule(items);
+            expect(items[0].scheduledAt).toBe('2026-01-30 09:00');
+            expect(sorted[0].scheduledAt).toBe('2026-01-25 09:00');
+        });
+    });
+    describe('updateStatus', () => {
+        it('updates status from draft to ready', () => {
+            const draftsDir = path.join(testDir, 'drafts');
+            const postDir = path.join(draftsDir, 'test-post');
+            fs.mkdirSync(postDir, { recursive: true });
+            const xFile = path.join(postDir, 'x.md');
+            fs.writeFileSync(xFile, '# Test\n\n## Post\n```\ncontent\n```\n\n## Status\ndraft\n\n## Media\nNone');
+            const item = {
+                id: 'D001',
+                folder: 'test-post',
+                title: 'Test',
+                post: 'content',
+                published: '',
+                media: 'None',
+                postedAt: '',
+                scheduledAt: '',
+                status: 'draft',
+                path: postDir,
+                xFile,
+            };
+            updateStatus(item, 'ready');
+            const content = fs.readFileSync(xFile, 'utf-8');
+            expect(content).toContain('## Status\nready');
+        });
+        it('updates status from ready to draft', () => {
+            const draftsDir = path.join(testDir, 'drafts');
+            const postDir = path.join(draftsDir, 'test-post');
+            fs.mkdirSync(postDir, { recursive: true });
+            const xFile = path.join(postDir, 'x.md');
+            fs.writeFileSync(xFile, '# Test\n\n## Post\n```\ncontent\n```\n\n## Status\nready\n\n## Media\nNone');
+            const item = {
+                id: 'D001',
+                folder: 'test-post',
+                title: 'Test',
+                post: 'content',
+                published: '',
+                media: 'None',
+                postedAt: '',
+                scheduledAt: '',
+                status: 'ready',
+                path: postDir,
+                xFile,
+            };
+            updateStatus(item, 'draft');
+            const content = fs.readFileSync(xFile, 'utf-8');
+            expect(content).toContain('## Status\ndraft');
+        });
+    });
+    describe('updateSchedule', () => {
+        it('updates scheduled date', () => {
+            const draftsDir = path.join(testDir, 'drafts');
+            const postDir = path.join(draftsDir, 'test-post');
+            fs.mkdirSync(postDir, { recursive: true });
+            const xFile = path.join(postDir, 'x.md');
+            fs.writeFileSync(xFile, '# Test\n\n## Post\n```\ncontent\n```\n\n## Scheduled\n\n## Posted\n');
+            const item = {
+                id: 'D001',
+                folder: 'test-post',
+                title: 'Test',
+                post: 'content',
+                published: '',
+                media: 'None',
+                postedAt: '',
+                scheduledAt: '',
+                status: 'draft',
+                path: postDir,
+                xFile,
+            };
+            updateSchedule(item, '2026-01-27 09:00');
+            const content = fs.readFileSync(xFile, 'utf-8');
+            expect(content).toContain('## Scheduled\n2026-01-27 09:00');
+        });
+    });
+    describe('moveToPosts', () => {
+        it('moves draft folder to posts', () => {
+            const draftsDir = path.join(testDir, 'drafts');
+            const postsDir = path.join(testDir, 'posts');
+            const postDir = path.join(draftsDir, 'test-post');
+            fs.mkdirSync(postDir, { recursive: true });
+            fs.mkdirSync(postsDir, { recursive: true });
+            const xFile = path.join(postDir, 'x.md');
+            fs.writeFileSync(xFile, '# Test\n\n## Post\n```\ncontent\n```\n\n## Status\nready\n\n## Media\nNone');
+            const item = {
+                id: 'D001',
+                folder: 'test-post',
+                title: 'Test',
+                post: 'content',
+                published: '',
+                media: 'None',
+                postedAt: '',
+                scheduledAt: '',
+                status: 'ready',
+                path: postDir,
+                xFile,
+            };
+            moveToPosts(item, testDir);
+            expect(fs.existsSync(postDir)).toBe(false);
+            expect(fs.existsSync(path.join(postsDir, 'test-post'))).toBe(true);
+        });
+        it('removes status field from file', () => {
+            const draftsDir = path.join(testDir, 'drafts');
+            const postsDir = path.join(testDir, 'posts');
+            const postDir = path.join(draftsDir, 'test-post');
+            fs.mkdirSync(postDir, { recursive: true });
+            fs.mkdirSync(postsDir, { recursive: true });
+            const xFile = path.join(postDir, 'x.md');
+            fs.writeFileSync(xFile, '# Test\n\n## Post\n```\ncontent\n```\n\n## Status\nready\n\n## Media\nNone');
+            const item = {
+                id: 'D001',
+                folder: 'test-post',
+                title: 'Test',
+                post: 'content',
+                published: '',
+                media: 'None',
+                postedAt: '',
+                scheduledAt: '',
+                status: 'ready',
+                path: postDir,
+                xFile,
+            };
+            moveToPosts(item, testDir);
+            const newXFile = path.join(postsDir, 'test-post', 'x.md');
+            const content = fs.readFileSync(newXFile, 'utf-8');
+            expect(content).not.toContain('## Status');
+        });
+        it('creates posts directory if missing', () => {
+            const draftsDir = path.join(testDir, 'drafts');
+            const postDir = path.join(draftsDir, 'test-post');
+            fs.mkdirSync(postDir, { recursive: true });
+            const xFile = path.join(postDir, 'x.md');
+            fs.writeFileSync(xFile, '# Test\n\n## Post\n```\ncontent\n```');
+            const item = {
+                id: 'D001',
+                folder: 'test-post',
+                title: 'Test',
+                post: 'content',
+                published: '',
+                media: 'None',
+                postedAt: '',
+                scheduledAt: '',
+                status: 'draft',
+                path: postDir,
+                xFile,
+            };
+            moveToPosts(item, testDir);
+            expect(fs.existsSync(path.join(testDir, 'posts', 'test-post'))).toBe(true);
+        });
+    });
+    describe('moveToDrafts', () => {
+        it('moves post folder to drafts', () => {
+            const postsDir = path.join(testDir, 'posts');
+            const draftsDir = path.join(testDir, 'drafts');
+            const postDir = path.join(postsDir, 'test-post');
+            fs.mkdirSync(postDir, { recursive: true });
+            fs.mkdirSync(draftsDir, { recursive: true });
+            const xFile = path.join(postDir, 'x.md');
+            fs.writeFileSync(xFile, '# Test\n\n## Post\n```\ncontent\n```\n\n## Media\nNone');
+            const item = {
+                id: 'P001',
+                folder: 'test-post',
+                title: 'Test',
+                post: 'content',
+                published: '',
+                media: 'None',
+                postedAt: '',
+                scheduledAt: '',
+                status: 'draft',
+                path: postDir,
+                xFile,
+            };
+            moveToDrafts(item, testDir);
+            expect(fs.existsSync(postDir)).toBe(false);
+            expect(fs.existsSync(path.join(draftsDir, 'test-post'))).toBe(true);
+        });
+        it('adds status field to file', () => {
+            const postsDir = path.join(testDir, 'posts');
+            const draftsDir = path.join(testDir, 'drafts');
+            const postDir = path.join(postsDir, 'test-post');
+            fs.mkdirSync(postDir, { recursive: true });
+            fs.mkdirSync(draftsDir, { recursive: true });
+            const xFile = path.join(postDir, 'x.md');
+            fs.writeFileSync(xFile, '# Test\n\n## Post\n```\ncontent\n```\n\n## Media\nNone');
+            const item = {
+                id: 'P001',
+                folder: 'test-post',
+                title: 'Test',
+                post: 'content',
+                published: '',
+                media: 'None',
+                postedAt: '',
+                scheduledAt: '',
+                status: 'draft',
+                path: postDir,
+                xFile,
+            };
+            moveToDrafts(item, testDir);
+            const newXFile = path.join(draftsDir, 'test-post', 'x.md');
+            const content = fs.readFileSync(newXFile, 'utf-8');
+            expect(content).toContain('## Status\nready');
+        });
+    });
+    describe('addPublishedUrl', () => {
+        it('adds published URL to post', () => {
+            const postsDir = path.join(testDir, 'posts');
+            const postDir = path.join(postsDir, 'test-post');
+            fs.mkdirSync(postDir, { recursive: true });
+            const xFile = path.join(postDir, 'x.md');
+            fs.writeFileSync(xFile, '# Test\n\n## Post\n```\ncontent\n```\n\n## Posted\n\n## Published\n');
+            const item = {
+                id: 'P001',
+                folder: 'test-post',
+                title: 'Test',
+                post: 'content',
+                published: '',
+                media: 'None',
+                postedAt: '',
+                scheduledAt: '',
+                status: 'draft',
+                path: postDir,
+                xFile,
+            };
+            addPublishedUrl(item, 'https://x.com/user/status/123');
+            const content = fs.readFileSync(xFile, 'utf-8');
+            expect(content).toContain('## Published\nhttps://x.com/user/status/123');
+        });
+        it('throws error for invalid URL', () => {
+            const postsDir = path.join(testDir, 'posts');
+            const postDir = path.join(postsDir, 'test-post');
+            fs.mkdirSync(postDir, { recursive: true });
+            const xFile = path.join(postDir, 'x.md');
+            fs.writeFileSync(xFile, '# Test\n\n## Post\n```\ncontent\n```');
+            const item = {
+                id: 'P001',
+                folder: 'test-post',
+                title: 'Test',
+                post: 'content',
+                published: '',
+                media: 'None',
+                postedAt: '',
+                scheduledAt: '',
+                status: 'draft',
+                path: postDir,
+                xFile,
+            };
+            expect(() => addPublishedUrl(item, 'not-a-url')).toThrow('Invalid URL');
+        });
+        it('uses scheduled date for posted date if available', () => {
+            const postsDir = path.join(testDir, 'posts');
+            const postDir = path.join(postsDir, 'test-post');
+            fs.mkdirSync(postDir, { recursive: true });
+            const xFile = path.join(postDir, 'x.md');
+            fs.writeFileSync(xFile, '# Test\n\n## Post\n```\ncontent\n```\n\n## Scheduled\n2026-01-27 09:00\n\n## Posted\n\n## Published\n');
+            const item = {
+                id: 'P001',
+                folder: 'test-post',
+                title: 'Test',
+                post: 'content',
+                published: '',
+                media: 'None',
+                postedAt: '',
+                scheduledAt: '2026-01-27 09:00',
+                status: 'draft',
+                path: postDir,
+                xFile,
+            };
+            addPublishedUrl(item, 'https://x.com/user/status/123');
+            const content = fs.readFileSync(xFile, 'utf-8');
+            expect(content).toContain('## Posted\n2026-01-27 09:00');
+        });
+    });
+    describe('deleteDraft', () => {
+        it('deletes draft folder', () => {
+            const draftsDir = path.join(testDir, 'drafts');
+            const postDir = path.join(draftsDir, 'test-post');
+            fs.mkdirSync(postDir, { recursive: true });
+            const xFile = path.join(postDir, 'x.md');
+            fs.writeFileSync(xFile, '# Test\n\n## Post\n```\ncontent\n```');
+            const item = {
+                id: 'D001',
+                folder: 'test-post',
+                title: 'Test',
+                post: 'content',
+                published: '',
+                media: 'None',
+                postedAt: '',
+                scheduledAt: '',
+                status: 'draft',
+                path: postDir,
+                xFile,
+            };
+            deleteDraft(item);
+            expect(fs.existsSync(postDir)).toBe(false);
+        });
+        it('deletes folder with nested files', () => {
+            const draftsDir = path.join(testDir, 'drafts');
+            const postDir = path.join(draftsDir, 'test-post');
+            const assetsDir = path.join(postDir, 'assets');
+            fs.mkdirSync(assetsDir, { recursive: true });
+            fs.writeFileSync(path.join(postDir, 'x.md'), '# Test');
+            fs.writeFileSync(path.join(assetsDir, 'image.png'), 'fake image data');
+            const item = {
+                id: 'D001',
+                folder: 'test-post',
+                title: 'Test',
+                post: 'content',
+                published: '',
+                media: 'None',
+                postedAt: '',
+                scheduledAt: '',
+                status: 'draft',
+                path: postDir,
+                xFile: path.join(postDir, 'x.md'),
+            };
+            deleteDraft(item);
+            expect(fs.existsSync(postDir)).toBe(false);
+        });
+    });
+    describe('Edge Cases', () => {
+        describe('Unicode and special characters', () => {
+            it('handles unicode in title', () => {
+                const item = createDraft('こんにちは世界 🌍', testDir);
+                expect(fs.existsSync(item.path)).toBe(true);
+                const content = fs.readFileSync(item.xFile, 'utf-8');
+                expect(content).toContain('# こんにちは世界 🌍');
+            });
+            it('handles emoji-only title', () => {
+                const item = createDraft('🚀🔥💯', testDir);
+                expect(fs.existsSync(item.path)).toBe(true);
+            });
+            it('parses post content with unicode', () => {
+                const draftsDir = path.join(testDir, 'drafts');
+                const postDir = path.join(draftsDir, 'unicode-post');
+                fs.mkdirSync(postDir, { recursive: true });
+                fs.writeFileSync(path.join(postDir, 'x.md'), '# Unicode Test\n\n## Post\n```\n日本語テスト 🎉\n```');
+                const result = parseContent(draftsDir, 'D');
+                expect(result[0].post).toBe('日本語テスト 🎉');
+            });
+        });
+        describe('Malformed x.md files', () => {
+            it('handles empty x.md file', () => {
+                const draftsDir = path.join(testDir, 'drafts');
+                const postDir = path.join(draftsDir, 'empty-post');
+                fs.mkdirSync(postDir, { recursive: true });
+                fs.writeFileSync(path.join(postDir, 'x.md'), '');
+                const result = parseContent(draftsDir, 'D');
+                expect(result).toHaveLength(1);
+                // Falls back to folder name when title is missing
+                expect(result[0].title).toBe('empty-post');
+                // Falls back to "(no content)" placeholder when post is empty
+                expect(result[0].post).toBe('(no content)');
+            });
+            it('handles x.md with only title', () => {
+                const draftsDir = path.join(testDir, 'drafts');
+                const postDir = path.join(draftsDir, 'title-only');
+                fs.mkdirSync(postDir, { recursive: true });
+                fs.writeFileSync(path.join(postDir, 'x.md'), '# Just a Title');
+                const result = parseContent(draftsDir, 'D');
+                expect(result).toHaveLength(1);
+                expect(result[0].title).toBe('Just a Title');
+                // Falls back to "(no content)" placeholder when post is empty
+                expect(result[0].post).toBe('(no content)');
+            });
+            it('handles x.md with unclosed code block', () => {
+                const draftsDir = path.join(testDir, 'drafts');
+                const postDir = path.join(draftsDir, 'unclosed');
+                fs.mkdirSync(postDir, { recursive: true });
+                fs.writeFileSync(path.join(postDir, 'x.md'), '# Title\n\n## Post\n```\nThis code block never closes');
+                const result = parseContent(draftsDir, 'D');
+                expect(result).toHaveLength(1);
+                // Should still parse something even with unclosed block
+                expect(result[0].title).toBe('Title');
+            });
+            it('handles x.md with multiple post sections (uses first)', () => {
+                const draftsDir = path.join(testDir, 'drafts');
+                const postDir = path.join(draftsDir, 'multi-post');
+                fs.mkdirSync(postDir, { recursive: true });
+                fs.writeFileSync(path.join(postDir, 'x.md'), '# Title\n\n## Post\n```\nFirst\n```\n\n## Post\n```\nSecond\n```');
+                const result = parseContent(draftsDir, 'D');
+                expect(result).toHaveLength(1);
+                expect(result[0].post).toBe('First');
+            });
+            it('handles x.md with status variations', () => {
+                const draftsDir = path.join(testDir, 'drafts');
+                const postDir = path.join(draftsDir, 'status-test');
+                fs.mkdirSync(postDir, { recursive: true });
+                fs.writeFileSync(path.join(postDir, 'x.md'), '# Title\n\n## Post\n```\ncontent\n```\n\n## Status\n  ready  ');
+                const result = parseContent(draftsDir, 'D');
+                expect(result[0].status).toBe('ready');
+            });
+        });
+        describe('Edge cases in findItem', () => {
+            beforeEach(() => {
+                const draftsDir = path.join(testDir, 'drafts');
+                fs.mkdirSync(path.join(draftsDir, 'test-post'), { recursive: true });
+                fs.mkdirSync(path.join(draftsDir, 'test-post-2'), { recursive: true });
+                fs.writeFileSync(path.join(draftsDir, 'test-post', 'x.md'), '# Test\n\n## Post\n```\ncontent\n```');
+                fs.writeFileSync(path.join(draftsDir, 'test-post-2', 'x.md'), '# Test 2\n\n## Post\n```\ncontent\n```');
+            });
+            it('returns exact match over partial', () => {
+                const item = findItem('test-post', testDir);
+                expect(item?.folder).toBe('test-post');
+            });
+            it('empty query matches first item (partial match behavior)', () => {
+                const item = findItem('', testDir);
+                // Empty string is a substring of any folder name
+                expect(item).not.toBeNull();
+            });
+            it('folder matching is case-sensitive', () => {
+                const item = findItem('TEST-POST', testDir);
+                // Case-sensitive: uppercase won't match lowercase folder
+                expect(item).toBeNull();
+            });
+        });
+        describe('Large content handling', () => {
+            it('handles large post content', () => {
+                const draftsDir = path.join(testDir, 'drafts');
+                const postDir = path.join(draftsDir, 'large-post');
+                fs.mkdirSync(postDir, { recursive: true });
+                const largeContent = 'A'.repeat(50000);
+                fs.writeFileSync(path.join(postDir, 'x.md'), `# Large Post\n\n## Post\n\`\`\`\n${largeContent}\n\`\`\``);
+                const result = parseContent(draftsDir, 'D');
+                expect(result).toHaveLength(1);
+                expect(result[0].post.length).toBe(50000);
+            });
+            it('handles many posts in directory', () => {
+                const draftsDir = path.join(testDir, 'drafts');
+                for (let i = 0; i < 100; i++) {
+                    const postDir = path.join(draftsDir, `post-${i}`);
+                    fs.mkdirSync(postDir, { recursive: true });
+                    fs.writeFileSync(path.join(postDir, 'x.md'), `# Post ${i}\n\n## Post\n\`\`\`\ncontent ${i}\n\`\`\``);
+                }
+                const result = parseContent(draftsDir, 'D');
+                expect(result).toHaveLength(100);
+            });
+        });
+        describe('createDraft edge cases', () => {
+            it('throws error for very long title (filesystem limit)', () => {
+                const longTitle = 'A'.repeat(500);
+                // Most filesystems have 255 char limit for names
+                expect(() => createDraft(longTitle, testDir)).toThrow();
+            });
+            it('handles title with only special characters', () => {
+                const item = createDraft('!@#$%^&*()', testDir);
+                expect(fs.existsSync(item.path)).toBe(true);
+            });
+            it('preserves whitespace in title (uses original for header)', () => {
+                const item = createDraft('  Trimmed Title  ', testDir);
+                expect(fs.existsSync(item.path)).toBe(true);
+                const content = fs.readFileSync(item.xFile, 'utf-8');
+                // Title is stored as-is in the template
+                expect(content).toContain('#   Trimmed Title  ');
+            });
+        });
+        describe('Date parsing edge cases', () => {
+            it('handles invalid scheduled date format', () => {
+                const draftsDir = path.join(testDir, 'drafts');
+                const postDir = path.join(draftsDir, 'bad-date');
+                fs.mkdirSync(postDir, { recursive: true });
+                fs.writeFileSync(path.join(postDir, 'x.md'), '# Test\n\n## Post\n```\ncontent\n```\n\n## Scheduled\nnot-a-date');
+                const result = parseContent(draftsDir, 'D');
+                expect(result[0].scheduledAt).toBe('not-a-date');
+            });
+            it('sorts invalid dates consistently', () => {
+                const items = [
+                    { scheduledAt: 'invalid' },
+                    { scheduledAt: '2026-01-25 09:00' },
+                    { scheduledAt: '' },
+                ];
+                const sorted = sortBySchedule(items);
+                expect(sorted[0].scheduledAt).toBe('2026-01-25 09:00');
+            });
+        });
+        describe('Filesystem edge cases', () => {
+            it('includes directories without x.md with defaults', () => {
+                const draftsDir = path.join(testDir, 'drafts');
+                fs.mkdirSync(path.join(draftsDir, 'empty-folder'), { recursive: true });
+                fs.mkdirSync(path.join(draftsDir, 'with-x-md'), { recursive: true });
+                fs.writeFileSync(path.join(draftsDir, 'with-x-md', 'x.md'), '# Test\n\n## Post\n```\ncontent\n```');
+                const result = parseContent(draftsDir, 'D');
+                // Both folders are included, even empty ones (folder name as title)
+                expect(result).toHaveLength(2);
+                const folders = result.map(r => r.folder).sort();
+                expect(folders).toEqual(['empty-folder', 'with-x-md']);
+            });
+            it('handles symlinks gracefully', () => {
+                const draftsDir = path.join(testDir, 'drafts');
+                fs.mkdirSync(draftsDir, { recursive: true });
+                const realDir = path.join(testDir, 'real-post');
+                fs.mkdirSync(realDir, { recursive: true });
+                fs.writeFileSync(path.join(realDir, 'x.md'), '# Symlinked\n\n## Post\n```\ncontent\n```');
+                try {
+                    fs.symlinkSync(realDir, path.join(draftsDir, 'linked-post'));
+                    const result = parseContent(draftsDir, 'D');
+                    expect(result).toHaveLength(1);
+                }
+                catch {
+                    // Skip test if symlinks not supported
+                }
+            });
+        });
+    });
+});