noslop 0.1.0

package/dist/lib/content.js

@@ -0,0 +1,463 @@
+import fs from 'fs';
+import path from 'path';
+/**
+ * Validate that a string is a valid URL
+ * @param str - String to validate
+ * @returns True if valid URL, false otherwise
+ */
+export function isValidUrl(str) {
+    try {
+        new URL(str);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validate a query string for path traversal attempts
+ * @param query - Query string to validate
+ * @throws Error if query contains path traversal patterns
+ */
+function validateQuery(query) {
+    if (query.includes('..') || query.startsWith('/') || query.includes('\\')) {
+        throw new Error('Invalid query: path traversal not allowed');
+    }
+}
+/**
+ * Get the paths to posts and drafts directories
+ * @param cwd - Working directory (defaults to process.cwd())
+ * @returns Object with postsDir and draftsDir paths
+ */
+export function getContentDirs(cwd = process.cwd()) {
+    return {
+        postsDir: path.join(cwd, 'posts'),
+        draftsDir: path.join(cwd, 'drafts'),
+    };
+}
+/**
+ * Check if the current directory is a noslop project
+ * @param cwd - Working directory to check
+ * @returns True if drafts/ or posts/ directory exists
+ */
+export function isNoslopProject(cwd = process.cwd()) {
+    const { postsDir, draftsDir } = getContentDirs(cwd);
+    return fs.existsSync(postsDir) || fs.existsSync(draftsDir);
+}
+/**
+ * Parse content from a directory into ContentItem objects
+ * @param dir - Directory containing content folders
+ * @param prefix - ID prefix ('D' for drafts, 'P' for posts)
+ * @returns Array of parsed content items, sorted alphabetically by folder name
+ */
+export function parseContent(dir, prefix) {
+    if (!fs.existsSync(dir)) {
+        return [];
+    }
+    let folders;
+    try {
+        folders = fs
+            .readdirSync(dir)
+            .filter(f => {
+            try {
+                return fs.statSync(path.join(dir, f)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        })
+            .filter(f => !f.startsWith('.'))
+            .sort();
+    }
+    catch (error) {
+        throw new Error(`Failed to read directory ${dir}: ${error.message}`);
+    }
+    return folders.map((folder, i) => {
+        const id = `${prefix}${String(i + 1).padStart(3, '0')}`;
+        const xFile = path.join(dir, folder, 'x.md');
+        let post = '', published = '', media = '', title = '', status = 'draft';
+        let postedAt = '', scheduledAt = '';
+        if (fs.existsSync(xFile)) {
+            try {
+                const content = fs.readFileSync(xFile, 'utf-8');
+                const titleMatch = content.match(/^# (.+)/m);
+                const postMatch = content.match(/## Post\n```\n([\s\S]*?)\n```/);
+                const pubMatch = content.match(/## Published\n(.+)/);
+                const mediaMatch = content.match(/## Media\n(.+)/);
+                const postedMatch = content.match(/## Posted\n(.+)/);
+                const scheduledMatch = content.match(/## Scheduled\n(.+)/);
+                const statusMatch = content.match(/## Status\n(.+)/);
+                title = titleMatch ? titleMatch[1].trim() : folder;
+                post = postMatch ? postMatch[1].trim() : '(no content)';
+                published = pubMatch ? pubMatch[1].trim() : '';
+                media = mediaMatch ? mediaMatch[1].trim() : 'None';
+                const rawStatus = statusMatch ? statusMatch[1].trim() : 'draft';
+                status = rawStatus === 'ready' ? 'ready' : 'draft';
+                postedAt = postedMatch ? postedMatch[1].trim() : '';
+                scheduledAt = scheduledMatch ? scheduledMatch[1].trim() : '';
+            }
+            catch {
+                // If we can't read the file, use defaults
+                title = folder;
+                post = '(error reading file)';
+            }
+        }
+        return {
+            id,
+            folder,
+            title,
+            post,
+            published,
+            media,
+            postedAt,
+            scheduledAt,
+            status,
+            path: path.join(dir, folder),
+            xFile,
+        };
+    });
+}
+/**
+ * Get all drafts from the drafts directory
+ * @param cwd - Working directory
+ * @returns Array of draft content items
+ */
+export function getDrafts(cwd = process.cwd()) {
+    const { draftsDir } = getContentDirs(cwd);
+    return parseContent(draftsDir, 'D');
+}
+/**
+ * Get all posts from the posts directory
+ * @param cwd - Working directory
+ * @returns Array of post content items
+ */
+export function getPosts(cwd = process.cwd()) {
+    const { postsDir } = getContentDirs(cwd);
+    return parseContent(postsDir, 'P');
+}
+/**
+ * Get all content (drafts + posts)
+ * @param cwd - Working directory
+ * @returns Object with drafts and posts arrays
+ */
+export function getAllContent(cwd = process.cwd()) {
+    return {
+        drafts: getDrafts(cwd),
+        posts: getPosts(cwd),
+    };
+}
+/**
+ * Find a content item by folder name or ID
+ * @param query - Folder name (exact or partial) or ID (D001, P001)
+ * @param cwd - Working directory
+ * @returns Matching content item or null if not found
+ * @throws Error if query contains path traversal patterns
+ * @example
+ * findItem('monday-motivation') // exact folder match
+ * findItem('monday') // partial folder match
+ * findItem('D001') // ID match
+ */
+export function findItem(query, cwd = process.cwd()) {
+    validateQuery(query);
+    const { drafts, posts } = getAllContent(cwd);
+    const all = [...drafts, ...posts];
+    // Exact folder match
+    let item = all.find(i => i.folder === query);
+    if (item) {
+        return item;
+    }
+    // Partial folder match
+    item = all.find(i => i.folder.includes(query));
+    if (item) {
+        return item;
+    }
+    // ID match (D001, P001)
+    item = all.find(i => i.id.toLowerCase() === query.toLowerCase());
+    return item || null;
+}
+/**
+ * Create a new draft with the given title
+ * @param title - Title for the draft (will be slugified for folder name)
+ * @param cwd - Working directory
+ * @returns The created ContentItem
+ * @throws Error if draft creation fails
+ */
+export function createDraft(title, cwd = process.cwd()) {
+    const { draftsDir } = getContentDirs(cwd);
+    // Ensure drafts directory exists
+    try {
+        if (!fs.existsSync(draftsDir)) {
+            fs.mkdirSync(draftsDir, { recursive: true });
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to create drafts directory: ${error.message}`);
+    }
+    // Generate folder name from title
+    const folder = title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+    const folderPath = path.join(draftsDir, folder);
+    const xFile = path.join(folderPath, 'x.md');
+    // Create folder and file
+    try {
+        fs.mkdirSync(folderPath, { recursive: true });
+    }
+    catch (error) {
+        throw new Error(`Failed to create draft folder ${folderPath}: ${error.message}`);
+    }
+    const content = `# ${title}
+
+## Post
+\`\`\`
+
+\`\`\`
+
+## Status
+draft
+
+## Media
+None
+
+## Scheduled
+
+## Posted
+
+## Published
+`;
+    try {
+        fs.writeFileSync(xFile, content);
+    }
+    catch (error) {
+        throw new Error(`Failed to write draft file ${xFile}: ${error.message}`);
+    }
+    return {
+        id: 'D001',
+        folder,
+        title,
+        post: '',
+        published: '',
+        media: 'None',
+        postedAt: '',
+        scheduledAt: '',
+        status: 'draft',
+        path: folderPath,
+        xFile,
+    };
+}
+/**
+ * Update the status of a content item
+ * @param item - Content item to update
+ * @param newStatus - New status ('draft' or 'ready')
+ * @throws Error if file operations fail
+ */
+export function updateStatus(item, newStatus) {
+    if (!fs.existsSync(item.xFile)) {
+        return;
+    }
+    let content;
+    try {
+        content = fs.readFileSync(item.xFile, 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to read file ${item.xFile}: ${error.message}`);
+    }
+    if (content.includes('## Status\n')) {
+        content = content.replace(/## Status\n.+/, `## Status\n${newStatus}`);
+    }
+    else {
+        content = content.replace(/## Media\n/, `## Status\n${newStatus}\n\n## Media\n`);
+    }
+    try {
+        fs.writeFileSync(item.xFile, content);
+    }
+    catch (error) {
+        throw new Error(`Failed to write file ${item.xFile}: ${error.message}`);
+    }
+}
+/**
+ * Update the scheduled date of a content item
+ * @param item - Content item to update
+ * @param datetime - Scheduled datetime string (YYYY-MM-DD HH:MM)
+ * @throws Error if file operations fail
+ */
+export function updateSchedule(item, datetime) {
+    if (!fs.existsSync(item.xFile)) {
+        return;
+    }
+    let content;
+    try {
+        content = fs.readFileSync(item.xFile, 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to read file ${item.xFile}: ${error.message}`);
+    }
+    if (content.includes('## Scheduled\n')) {
+        content = content.replace(/## Scheduled\n.*/, `## Scheduled\n${datetime}`);
+    }
+    else {
+        content = content.replace(/## Posted\n/, `## Scheduled\n${datetime}\n\n## Posted\n`);
+    }
+    try {
+        fs.writeFileSync(item.xFile, content);
+    }
+    catch (error) {
+        throw new Error(`Failed to write file ${item.xFile}: ${error.message}`);
+    }
+}
+/**
+ * Move a draft to the posts folder
+ * @param item - Content item to move
+ * @param cwd - Working directory
+ * @throws Error if move operation fails
+ */
+export function moveToPosts(item, cwd = process.cwd()) {
+    const { postsDir } = getContentDirs(cwd);
+    // Ensure posts directory exists
+    try {
+        if (!fs.existsSync(postsDir)) {
+            fs.mkdirSync(postsDir, { recursive: true });
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to create posts directory: ${error.message}`);
+    }
+    // Remove status field from file
+    if (fs.existsSync(item.xFile)) {
+        try {
+            let content = fs.readFileSync(item.xFile, 'utf-8');
+            content = content.replace(/## Status\n.+\n\n?/, '');
+            fs.writeFileSync(item.xFile, content);
+        }
+        catch (error) {
+            throw new Error(`Failed to update file ${item.xFile}: ${error.message}`);
+        }
+    }
+    // Move to posts
+    const newPath = path.join(postsDir, item.folder);
+    try {
+        fs.renameSync(item.path, newPath);
+    }
+    catch (error) {
+        throw new Error(`Failed to move ${item.path} to ${newPath}: ${error.message}`);
+    }
+}
+/**
+ * Move a post back to the drafts folder
+ * @param item - Content item to move
+ * @param cwd - Working directory
+ * @throws Error if move operation fails
+ */
+export function moveToDrafts(item, cwd = process.cwd()) {
+    const { draftsDir } = getContentDirs(cwd);
+    // Ensure drafts directory exists
+    try {
+        if (!fs.existsSync(draftsDir)) {
+            fs.mkdirSync(draftsDir, { recursive: true });
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to create drafts directory: ${error.message}`);
+    }
+    // Add status field
+    if (fs.existsSync(item.xFile)) {
+        try {
+            let content = fs.readFileSync(item.xFile, 'utf-8');
+            if (!content.includes('## Status\n')) {
+                content = content.replace(/## Media\n/, `## Status\nready\n\n## Media\n`);
+            }
+            else {
+                content = content.replace(/## Status\n.+/, '## Status\nready');
+            }
+            fs.writeFileSync(item.xFile, content);
+        }
+        catch (error) {
+            throw new Error(`Failed to update file ${item.xFile}: ${error.message}`);
+        }
+    }
+    // Move to drafts
+    const newPath = path.join(draftsDir, item.folder);
+    try {
+        fs.renameSync(item.path, newPath);
+    }
+    catch (error) {
+        throw new Error(`Failed to move ${item.path} to ${newPath}: ${error.message}`);
+    }
+}
+/**
+ * Add a published URL to a post
+ * @param item - Content item to update
+ * @param url - Published URL
+ * @throws Error if URL is invalid or file operations fail
+ */
+export function addPublishedUrl(item, url) {
+    if (!isValidUrl(url)) {
+        throw new Error(`Invalid URL: ${url}`);
+    }
+    if (!fs.existsSync(item.xFile)) {
+        return;
+    }
+    let content;
+    try {
+        content = fs.readFileSync(item.xFile, 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to read file ${item.xFile}: ${error.message}`);
+    }
+    // Set Posted date = Scheduled date (or now if no scheduled date)
+    const scheduledMatch = content.match(/## Scheduled\n(.+)/);
+    const postedDate = scheduledMatch ? scheduledMatch[1].trim() : formatDate(new Date());
+    if (content.includes('## Posted\n')) {
+        content = content.replace(/## Posted\n.*/, `## Posted\n${postedDate}`);
+    }
+    else {
+        content += `\n## Posted\n${postedDate}`;
+    }
+    if (content.includes('## Published\n')) {
+        content = content.replace(/## Published\n.*/, `## Published\n${url}`);
+    }
+    else {
+        content += `\n## Published\n${url}`;
+    }
+    try {
+        fs.writeFileSync(item.xFile, content);
+    }
+    catch (error) {
+        throw new Error(`Failed to write file ${item.xFile}: ${error.message}`);
+    }
+}
+/**
+ * Delete a draft
+ * @param item - Content item to delete
+ * @throws Error if delete operation fails
+ */
+export function deleteDraft(item) {
+    try {
+        fs.rmSync(item.path, { recursive: true });
+    }
+    catch (error) {
+        throw new Error(`Failed to delete ${item.path}: ${error.message}`);
+    }
+}
+/**
+ * Format a date as YYYY-MM-DD HH:MM
+ * @param date - Date to format
+ * @returns Formatted date string
+ */
+export function formatDate(date) {
+    return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')} ${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`;
+}
+/**
+ * Sort content items by scheduled date (oldest first)
+ * Unscheduled items are placed at the end
+ * @param items - Array of content items to sort
+ * @returns New sorted array (does not mutate original)
+ */
+export function sortBySchedule(items) {
+    return [...items].sort((a, b) => {
+        const dateA = a.scheduledAt || '9999-99-99';
+        const dateB = b.scheduledAt || '9999-99-99';
+        return dateA.localeCompare(dateB);
+    });
+}

package/dist/lib/content.test.d.ts

@@ -0,0 +1 @@
+export {};