vibeman 0.0.0 → 0.0.1

package/dist/runtime/api/lib/image-paste-drop-extension.js

@@ -0,0 +1,125 @@
+import { Extension } from '@tiptap/core';
+import { Plugin, PluginKey } from '@tiptap/pm/state';
+import { handleImageUpload } from './tiptap-utils.js';
+export const ImagePasteDrop = Extension.create({
+    name: 'imagePasteDrop',
+    addOptions() {
+        return {
+            upload: handleImageUpload,
+            onError: undefined,
+            onSuccess: undefined,
+            maxSize: 5 * 1024 * 1024, // 5MB
+            allowedTypes: [
+                'image/jpeg',
+                'image/jpg',
+                'image/png',
+                'image/gif',
+                'image/webp',
+                'image/svg+xml',
+            ],
+        };
+    },
+    addProseMirrorPlugins() {
+        const uploadAndInsertImages = (files, view, position) => {
+            files.forEach(async (file) => {
+                try {
+                    // Validate file size
+                    if (this.options.maxSize && file.size > this.options.maxSize) {
+                        const error = new Error(`File size exceeds maximum allowed (${this.options.maxSize / (1024 * 1024)}MB)`);
+                        this.options.onError?.(error);
+                        return;
+                    }
+                    // Insert placeholder first
+                    const placeholderTransaction = view.state.tr.insert(position, view.state.schema.text('🔄 Uploading...'));
+                    view.dispatch(placeholderTransaction);
+                    // Upload the image
+                    const uploadFunction = this.options.upload || handleImageUpload;
+                    const imageUrl = await uploadFunction(file);
+                    // Replace placeholder with actual image
+                    const filename = file.name.replace(/\.[^/.]+$/, '') || 'image';
+                    const imageNode = view.state.schema.nodes.image.create({
+                        src: imageUrl,
+                        alt: filename,
+                        title: filename,
+                    });
+                    // Find the placeholder text and replace it
+                    const currentState = view.state;
+                    let found = false;
+                    currentState.doc.descendants((node, pos) => {
+                        if (!found && node.isText && node.text === '🔄 Uploading...') {
+                            const replaceTransaction = currentState.tr.replaceRangeWith(pos, pos + node.nodeSize, imageNode);
+                            view.dispatch(replaceTransaction);
+                            found = true;
+                            return false;
+                        }
+                        return true;
+                    });
+                    this.options.onSuccess?.(imageUrl);
+                }
+                catch (error) {
+                    // Remove placeholder on error
+                    const currentState = view.state;
+                    currentState.doc.descendants((node, pos) => {
+                        if (node.isText && node.text === '🔄 Uploading...') {
+                            const deleteTransaction = currentState.tr.delete(pos, pos + node.nodeSize);
+                            view.dispatch(deleteTransaction);
+                            return false;
+                        }
+                        return true;
+                    });
+                    const errorMessage = error instanceof Error ? error : new Error('Upload failed');
+                    this.options.onError?.(errorMessage);
+                }
+            });
+        };
+        return [
+            new Plugin({
+                key: new PluginKey('imagePasteDrop'),
+                props: {
+                    handleDOMEvents: {
+                        // Handle drag and drop
+                        drop: (view, event) => {
+                            event.preventDefault();
+                            const { files } = event.dataTransfer;
+                            const imageFiles = Array.from(files).filter((file) => this.options.allowedTypes?.includes(file.type));
+                            if (imageFiles.length === 0) {
+                                return false;
+                            }
+                            // Get drop position
+                            const pos = view.posAtCoords({
+                                left: event.clientX,
+                                top: event.clientY,
+                            });
+                            if (!pos)
+                                return false;
+                            uploadAndInsertImages(imageFiles, view, pos.pos);
+                            return true;
+                        },
+                        // Handle paste
+                        paste: (view, event) => {
+                            const { files } = event.clipboardData;
+                            const imageFiles = Array.from(files).filter((file) => this.options.allowedTypes?.includes(file.type));
+                            if (imageFiles.length === 0) {
+                                return false;
+                            }
+                            event.preventDefault();
+                            // Insert at current cursor position
+                            const { selection } = view.state;
+                            uploadAndInsertImages(imageFiles, view, selection.from);
+                            return true;
+                        },
+                        // Prevent default drag behaviors
+                        dragover: (view, event) => {
+                            event.preventDefault();
+                            return false;
+                        },
+                        dragenter: (view, event) => {
+                            event.preventDefault();
+                            return false;
+                        },
+                    },
+                },
+            }),
+        ];
+    },
+});

package/dist/runtime/api/lib/logger.d.ts

@@ -0,0 +1,11 @@
+import { Logger } from 'pino';
+export declare const logger: Logger;
+export declare function createContextLogger(context: string): Logger;
+export declare const log: {
+    error: (message: string, error?: Error | unknown, context?: string) => void;
+    warn: (message: string, data?: unknown, context?: string) => void;
+    info: (message: string, data?: unknown, context?: string) => void;
+    debug: (message: string, data?: unknown, context?: string) => void;
+    trace: (message: string, data?: unknown, context?: string) => void;
+};
+export default logger;

package/dist/runtime/api/lib/logger.js

@@ -0,0 +1,188 @@
+import pino from 'pino';
+// Check if we're running in browser context
+const isBrowser = typeof globalThis !== 'undefined' && 'window' in globalThis;
+// Simple environment detection to avoid import issues
+function isDevelopment() {
+    return process.env.NODE_ENV === 'development';
+}
+// Environment detection - check both environment variable and process args for verbose mode
+const isVerbose = process.env.VERBOSE === 'true' ||
+    (typeof process !== 'undefined' &&
+        process.argv &&
+        (process.argv.includes('--verbose') || process.argv.includes('-v')));
+// Optional explicit log level/format override
+const envLogLevel = (process.env.VIBEMAN_LOG_LEVEL || process.env.LOG_LEVEL || '').toLowerCase();
+const envLogStyle = (process.env.VIBEMAN_LOG_STYLE || process.env.LOG_STYLE || '').toLowerCase();
+const paramSplitter = process.env.VIBEMAN_LOG_SPLIT || process.env.LOG_SPLIT || ' | ';
+// Determine log level based on environment and verbose flag
+function getLogLevel() {
+    if (envLogLevel &&
+        ['silent', 'fatal', 'error', 'warn', 'info', 'debug', 'trace'].includes(envLogLevel)) {
+        return envLogLevel;
+    }
+    if (isVerbose)
+        return 'debug';
+    if (isDevelopment())
+        return 'info';
+    return 'error';
+}
+// Create logger configuration
+const loggerConfig = {
+    level: getLogLevel(),
+    ...(isBrowser
+        ? {
+            // Browser configuration - use simple console
+            browser: { asObject: false },
+        }
+        : {
+            // Node.js configuration
+            formatters: {
+                level: (label) => ({ level: label }),
+                log: (object) => object,
+            },
+            transport: {
+                target: 'pino-pretty',
+                options: (() => {
+                    const base = {
+                        colorize: true,
+                        translateTime: 'HH:MM:ss',
+                        ignore: 'pid,hostname',
+                    };
+                    if (envLogStyle !== 'pretty') {
+                        base.singleLine = false;
+                        base.hideObject = false; // allow error objects to render stacks
+                        return base;
+                    }
+                    // Pretty (multi-line) with inline context, print objects nicely
+                    base.levelFirst = true;
+                    base.messageFormat = (log, messageKey) => log?.context ? `[${log.context}] ${log[messageKey]}` : log[messageKey];
+                    return base;
+                })(),
+            },
+        }),
+};
+// Create the logger instance
+export const logger = pino(loggerConfig);
+// Context-aware logger factory
+export function createContextLogger(context) {
+    return logger.child({ context });
+}
+// Convenience methods for common logging patterns
+export const log = {
+    error: (message, error, context) => {
+        const contextLogger = context ? createContextLogger(context) : logger;
+        const msg = context ? `[${context}] ${message}` : message;
+        if (error instanceof Error) {
+            // Keep error object so stack renders, even in compact
+            contextLogger.error({ err: error }, msg);
+        }
+        else if (error) {
+            contextLogger.error({ err: error }, msg);
+        }
+        else {
+            contextLogger.error(msg);
+        }
+    },
+    warn: (message, data, context) => {
+        const contextLogger = context ? createContextLogger(context) : logger;
+        const msg = context ? `[${context}] ${message}` : message;
+        if (data && envLogStyle !== 'pretty') {
+            const entries = Object.entries(data);
+            const messageEntry = entries.find(([k]) => k === 'message');
+            const other = entries.filter(([k]) => k !== 'message');
+            const pairs = other.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(paramSplitter);
+            const body = (() => {
+                if (!messageEntry)
+                    return '';
+                const val = messageEntry[1];
+                if (typeof val === 'string')
+                    return `\n${val}`; // print as-is (newlines preserved)
+                return `\n${JSON.stringify(val, null, 2)}`;
+            })();
+            contextLogger.warn(pairs ? `${msg} ${pairs}${body}` : `${msg}${body}`);
+        }
+        else if (data) {
+            contextLogger.warn(data, msg);
+        }
+        else {
+            contextLogger.warn(msg);
+        }
+    },
+    info: (message, data, context) => {
+        const contextLogger = context ? createContextLogger(context) : logger;
+        const msg = context ? `[${context}] ${message}` : message;
+        if (data && envLogStyle !== 'pretty') {
+            const entries = Object.entries(data);
+            const messageEntry = entries.find(([k]) => k === 'message');
+            const other = entries.filter(([k]) => k !== 'message');
+            const pairs = other.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(paramSplitter);
+            const body = (() => {
+                if (!messageEntry)
+                    return '';
+                const val = messageEntry[1];
+                if (typeof val === 'string')
+                    return `\n${val}`;
+                return `\n${JSON.stringify(val, null, 2)}`;
+            })();
+            contextLogger.info(pairs ? `${msg} ${pairs}${body}` : `${msg}${body}`);
+        }
+        else if (data) {
+            contextLogger.info(data, msg);
+        }
+        else {
+            contextLogger.info(msg);
+        }
+    },
+    debug: (message, data, context) => {
+        const contextLogger = context ? createContextLogger(context) : logger;
+        const msg = context ? `[${context}] ${message}` : message;
+        if (data && envLogStyle !== 'pretty') {
+            const entries = Object.entries(data);
+            const messageEntry = entries.find(([k]) => k === 'message');
+            const other = entries.filter(([k]) => k !== 'message');
+            const pairs = other.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(paramSplitter);
+            const body = (() => {
+                if (!messageEntry)
+                    return '';
+                const val = messageEntry[1];
+                if (typeof val === 'string')
+                    return `\n${val}`;
+                return `\n${JSON.stringify(val, null, 2)}`;
+            })();
+            contextLogger.debug(pairs ? `${msg} ${pairs}${body}` : `${msg}${body}`);
+        }
+        else if (data) {
+            contextLogger.debug(data, msg);
+        }
+        else {
+            contextLogger.debug(msg);
+        }
+    },
+    trace: (message, data, context) => {
+        const contextLogger = context ? createContextLogger(context) : logger;
+        const msg = context ? `[${context}] ${message}` : message;
+        if (data && envLogStyle !== 'pretty') {
+            const entries = Object.entries(data);
+            const messageEntry = entries.find(([k]) => k === 'message');
+            const other = entries.filter(([k]) => k !== 'message');
+            const pairs = other.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(paramSplitter);
+            const body = (() => {
+                if (!messageEntry)
+                    return '';
+                const val = messageEntry[1];
+                if (typeof val === 'string')
+                    return `\n${val}`;
+                return `\n${JSON.stringify(val, null, 2)}`;
+            })();
+            contextLogger.trace(pairs ? `${msg} ${pairs}${body}` : `${msg}${body}`);
+        }
+        else if (data) {
+            contextLogger.trace(data, msg);
+        }
+        else {
+            contextLogger.trace(msg);
+        }
+    },
+};
+// Export default logger for direct use
+export default logger;

package/dist/runtime/api/lib/markdown-utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Convert markdown to HTML for Tiptap editor
+ */
+export declare function markdownToHtml(markdown: string): string;
+/**
+ * Convert HTML to markdown for storage
+ */
+export declare function htmlToMarkdown(html: string): string;

package/dist/runtime/api/lib/markdown-utils.js

@@ -0,0 +1,282 @@
+import { marked } from 'marked';
+import TurndownService from 'turndown';
+import { gfm } from 'turndown-plugin-gfm';
+marked.setOptions({
+    gfm: true,
+    breaks: false,
+});
+const turndownService = new TurndownService({
+    headingStyle: 'atx',
+    hr: '---',
+    bulletListMarker: '-',
+    codeBlockStyle: 'fenced',
+    fence: '```',
+});
+// Use GitHub Flavored Markdown plugin
+turndownService.use(gfm);
+// Custom rule for regular list items to use single space after dash
+turndownService.addRule('listItem', {
+    filter: (node) => {
+        return (node.nodeName === 'LI' && !node.getAttribute('data-type') // Not a task item
+        );
+    },
+    replacement: (content, node, _options) => {
+        content = content
+            .replace(/^\n+/, '') // Remove leading newlines
+            .replace(/\n+$/, '\n') // Replace trailing newlines with just one
+            .replace(/\n/gm, '\n  '); // Indent subsequent lines
+        let prefix = '- '; // Use single space after dash
+        const parent = node.parentNode;
+        if (parent && parent.nodeName === 'OL') {
+            const index = Array.prototype.indexOf.call(parent.children, node);
+            const start = parent.getAttribute('start');
+            const startIndex = start ? parseInt(start, 10) - 1 : 0;
+            prefix = startIndex + index + 1 + '. ';
+        }
+        return prefix + content + (node.nextSibling && !/\n$/.test(content) ? '\n' : '');
+    },
+});
+// Custom rule for TipTap TaskItems
+turndownService.addRule('tiptapTaskItem', {
+    filter: (node, _options) => {
+        return (node.nodeName === 'LI' &&
+            node.getAttribute('data-type') === 'taskItem' &&
+            node.getAttribute('data-checked') !== null);
+    },
+    replacement: (content, node) => {
+        const element = node;
+        const isChecked = element.getAttribute('data-checked') === 'true';
+        const checkbox = isChecked ? '[x]' : '[ ]';
+        // Extract text content from the div > p structure
+        const contentDiv = element.querySelector('div');
+        const textContent = contentDiv ? contentDiv.textContent?.trim() || '' : content.trim();
+        return `- ${checkbox} ${textContent}`;
+    },
+});
+// Custom rule for TipTap TaskLists - handles nested structure properly
+turndownService.addRule('tiptapTaskList', {
+    filter: (node) => {
+        return node.nodeName === 'UL' && node.getAttribute('data-type') === 'taskList';
+    },
+    replacement: (content, node) => {
+        // Process only direct child li elements to preserve nesting
+        const directItems = Array.from(node.children).filter((child) => child.nodeName === 'LI' && child.getAttribute('data-type') === 'taskItem');
+        if (directItems.length === 0)
+            return content;
+        const processTaskItem = (li, indent = '') => {
+            const isChecked = li.getAttribute('data-checked') === 'true';
+            const checkbox = isChecked ? '[x]' : '[ ]';
+            // Get text content from the div, excluding nested lists
+            const contentDiv = li.querySelector('div');
+            let textContent = '';
+            if (contentDiv) {
+                // Clone the div to avoid modifying the original
+                const tempDiv = contentDiv.cloneNode(true);
+                // Remove any nested ul elements from the clone to get just the text
+                const nestedLists = Array.from(tempDiv.querySelectorAll('ul'));
+                nestedLists.forEach((list) => {
+                    if (list instanceof Element) {
+                        list.remove();
+                    }
+                });
+                textContent = tempDiv.textContent?.trim() || '';
+            }
+            let result = `${indent}- ${checkbox} ${textContent}`;
+            // Process nested task lists
+            const nestedList = li.querySelector('ul[data-type="taskList"]');
+            if (nestedList) {
+                const nestedItems = Array.from(nestedList.children).filter((child) => child.nodeName === 'LI' && child.getAttribute('data-type') === 'taskItem');
+                nestedItems.forEach((nestedLi) => {
+                    if (nestedLi instanceof Element) {
+                        result += '\n' + processTaskItem(nestedLi, indent + '  ');
+                    }
+                });
+            }
+            return result;
+        };
+        return '\n' + directItems.map((li) => processTaskItem(li)).join('\n') + '\n';
+    },
+});
+// Override paragraph handling to preserve paragraph breaks
+// Ensure there is a blank line between paragraphs in markdown
+turndownService.addRule('paragraph', {
+    filter: 'p',
+    replacement: (content) => {
+        return '\n\n' + content.trim() + '\n\n';
+    },
+});
+/**
+ * Clean up HTML by removing <p> tags within <li> elements under <ul> or <ol> lists
+ */
+function cleanupListParagraphs(html) {
+    if (!html?.trim())
+        return html;
+    // Use DOM parsing to handle nested structures properly
+    if (typeof window !== 'undefined') {
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(html, 'text/html');
+        // Find all <li> elements within <ul> or <ol>
+        const listItems = doc.querySelectorAll('ul > li, ol > li');
+        listItems.forEach((li) => {
+            // Find all <p> tags directly within this <li>
+            const paragraphs = Array.from(li.querySelectorAll('p'));
+            paragraphs.forEach((p) => {
+                // Only remove <p> if it's a direct child or within the list item structure
+                if (p.parentElement === li ||
+                    (p.parentElement && ['UL', 'OL', 'LI'].includes(p.parentElement.nodeName))) {
+                    // Replace <p> with its content
+                    const content = p.innerHTML;
+                    const textNode = doc.createDocumentFragment();
+                    textNode.appendChild(doc.createTextNode(content));
+                    // For better HTML structure, we'll replace with the content directly
+                    p.outerHTML = content;
+                }
+            });
+        });
+        return doc.body.innerHTML;
+    }
+    // Fallback for server-side: use regex approach (less robust but works)
+    // Remove <p> and </p> tags within <li> elements
+    return html
+        .replace(/<li([^>]*)><p>/g, '<li$1>')
+        .replace(/<\/p><\/li>/g, '</li>')
+        .replace(/<\/p><ul>/g, '<ul>')
+        .replace(/<\/p><ol>/g, '<ol>')
+        .replace(/<\/ul><p>/g, '</ul>')
+        .replace(/<\/ol><p>/g, '</ol>');
+}
+/**
+ * Convert GFM checkbox HTML to Tiptap TaskItem format
+ */
+function convertToTiptapTaskItems(html) {
+    if (!html?.trim())
+        return html;
+    // Use DOM parsing for better accuracy
+    if (typeof window !== 'undefined') {
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(html, 'text/html');
+        // Process all ul elements, starting from the deepest nested ones
+        const lists = Array.from(doc.querySelectorAll('ul')).reverse();
+        lists.forEach((ul) => {
+            let hasTaskItems = false;
+            // Only process direct children li elements to preserve nesting
+            const directListItems = Array.from(ul.children).filter((child) => child.nodeName === 'LI');
+            directListItems.forEach((li) => {
+                const checkbox = li.querySelector('input[type="checkbox"]');
+                if (checkbox) {
+                    hasTaskItems = true;
+                    // Get the checkbox state
+                    const isChecked = checkbox.hasAttribute('checked');
+                    // Set TaskItem attributes
+                    li.setAttribute('data-type', 'taskItem');
+                    li.setAttribute('data-checked', isChecked ? 'true' : 'false');
+                    // Get the text content, preserving nested structure
+                    const clonedLi = li.cloneNode(true);
+                    // Remove the checkbox from the clone
+                    const clonedCheckbox = clonedLi.querySelector('input[type="checkbox"]');
+                    if (clonedCheckbox) {
+                        clonedCheckbox.remove();
+                    }
+                    // Extract nested lists to preserve them
+                    const nestedLists = Array.from(clonedLi.querySelectorAll('ul'));
+                    const nestedListsHTML = nestedLists.map((list) => list.outerHTML);
+                    // Remove nested lists temporarily to get just the text content
+                    nestedLists.forEach((list) => {
+                        if (list instanceof Element) {
+                            list.remove();
+                        }
+                    });
+                    // Get the text content
+                    const textContent = clonedLi.textContent?.trim() || '';
+                    // Create the proper TipTap structure
+                    let innerHTML = `
+            <label contenteditable="false">
+              <input type="checkbox" ${isChecked ? 'checked' : ''}>
+              <span></span>
+            </label>
+            <div>
+              <p>${textContent}</p>`;
+                    // Add back any nested lists, ensuring they have the correct data-type
+                    if (nestedListsHTML.length > 0) {
+                        nestedListsHTML.forEach((nestedHTML) => {
+                            // Make sure nested task lists have the correct data-type attribute
+                            let processedHTML = nestedHTML;
+                            if (nestedHTML.includes('data-type="taskItem"') &&
+                                !nestedHTML.includes('data-type="taskList"')) {
+                                processedHTML = nestedHTML.replace('<ul>', '<ul data-type="taskList">');
+                            }
+                            innerHTML += processedHTML;
+                        });
+                    }
+                    innerHTML += '</div>';
+                    li.innerHTML = innerHTML.trim();
+                }
+            });
+            // If this ul contains task items, mark it as a taskList
+            if (hasTaskItems) {
+                ul.setAttribute('data-type', 'taskList');
+            }
+        });
+        return doc.body.innerHTML;
+    }
+    // Fallback for server-side: use regex approach (less robust)
+    return (html
+        // First pass: Convert list items with checkboxes
+        .replace(/<li>(\s*)<input\s+([^>]*?)type="checkbox"([^>]*?)>([^<]*)/gi, (match, leadingSpace, beforeType, afterType, textContent) => {
+        const isChecked = beforeType.includes('checked') || afterType.includes('checked');
+        const cleanText = textContent.trim();
+        return `<li data-type="taskItem" data-checked="${isChecked ? 'true' : 'false'}">
+          <label contenteditable="false">
+            <input type="checkbox" ${isChecked ? 'checked' : ''}>
+            <span></span>
+          </label>
+          <div>
+            <p>${cleanText}</p>
+          </div>`;
+    })
+        // Second pass: Mark parent ul as taskList if it contains taskItems
+        .replace(/<ul>(\s*(?:<li[^>]*data-type="taskItem"[^>]*>[\s\S]*?<\/li>\s*)+)<\/ul>/gi, '<ul data-type="taskList">$1</ul>'));
+}
+/**
+ * Pre-process markdown to ensure proper task list item boundaries
+ */
+function preprocessMarkdownTaskItems(markdown) {
+    if (!markdown?.trim())
+        return markdown;
+    // Split markdown into lines
+    const lines = markdown.split('\n');
+    const processedLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const nextLine = i + 1 < lines.length ? lines[i + 1] : '';
+        processedLines.push(line);
+        // If current line is a task item and next line is not empty and not indented
+        // and not another list item, add a blank line to separate them
+        if (line.trim().match(/^-\s+\[[ x]\]/) &&
+            nextLine.trim() &&
+            !nextLine.match(/^-\s+/) &&
+            !nextLine.match(/^\s{2,}/)) {
+            processedLines.push(''); // Add blank line
+        }
+    }
+    return processedLines.join('\n');
+}
+/**
+ * Convert markdown to HTML for Tiptap editor
+ */
+export function markdownToHtml(markdown) {
+    if (!markdown?.trim())
+        return '';
+    const preprocessedMarkdown = preprocessMarkdownTaskItems(markdown);
+    const html = marked(preprocessedMarkdown);
+    return convertToTiptapTaskItems(html);
+}
+/**
+ * Convert HTML to markdown for storage
+ */
+export function htmlToMarkdown(html) {
+    if (!html?.trim())
+        return '';
+    const cleanedHtml = cleanupListParagraphs(html);
+    return turndownService.turndown(cleanedHtml);
+}

package/dist/runtime/api/lib/markdown-utils.test.d.ts

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