@nuvin/nuvin-cli 1.4.0 → 1.5.1-prerelease

package/dist/clipboard-CQ3xH9Xm.js

@@ -0,0 +1,152 @@
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { platform, tmpdir } from 'node:os';
+import { readFileSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+
+const execAsync = promisify(exec);
+async function hasClipboardFiles() {
+    try {
+        const os = platform();
+        if (os === 'darwin') {
+            // Check if clipboard contains image data - expanded format support
+            const { stdout } = await execAsync('osascript -e "clipboard info"');
+            return (stdout.includes('«class PNGf»') ||
+                stdout.includes('«class TIFF»') ||
+                stdout.includes('«class JPEG»') ||
+                stdout.includes('«class GIFf»') ||
+                stdout.includes('«class BMPf»') ||
+                stdout.includes('«class HEIF»') ||
+                stdout.includes('«class WEBP»'));
+        }
+        else if (os === 'linux') {
+            const { stdout } = await execAsync('xclip -selection clipboard -t TARGETS -o 2>/dev/null || echo ""');
+            return (stdout.includes('image/png') ||
+                stdout.includes('image/jpeg') ||
+                stdout.includes('image/gif') ||
+                stdout.includes('image/bmp') ||
+                stdout.includes('image/tiff') ||
+                stdout.includes('image/webp'));
+        }
+        else if (os === 'win32') {
+            try {
+                // Check if clipboard contains image data
+                const { stdout } = await execAsync("powershell -command \"if ([System.Windows.Forms.Clipboard]::ContainsImage()) { 'true' } else { 'false' }\" 2>$null");
+                return stdout.trim() === 'true';
+            }
+            catch {
+                return false;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+async function getClipboardFiles() {
+    try {
+        const os = platform();
+        if (os === 'darwin') {
+            return await getMacOSClipboardImage();
+        }
+        else if (os === 'linux') {
+            return await getLinuxClipboardImage();
+        }
+        else if (os === 'win32') {
+            return await getWindowsClipboardImage();
+        }
+        return [];
+    }
+    catch (error) {
+        console.warn('Failed to get clipboard files:', error);
+        return [];
+    }
+}
+async function getMacOSClipboardImage() {
+    const formats = [
+        { format: '«class PNGf»', extension: 'png', mimeType: 'image/png' },
+        { format: '«class JPEG»', extension: 'jpg', mimeType: 'image/jpeg' },
+        { format: '«class TIFF»', extension: 'tiff', mimeType: 'image/tiff' },
+        { format: '«class GIFf»', extension: 'gif', mimeType: 'image/gif' },
+        { format: '«class BMPf»', extension: 'bmp', mimeType: 'image/bmp' },
+    ];
+    for (const { format, extension, mimeType } of formats) {
+        try {
+            const tempPath = join(tmpdir(), `clipboard-${Date.now()}.${extension}`);
+            await execAsync(`osascript -e "
+        set imageData to the clipboard as ${format}
+        set fileRef to open for access POSIX file \\"${tempPath}\\" with write permission
+        write imageData to fileRef
+        close access fileRef
+      "`);
+            const buffer = readFileSync(tempPath);
+            unlinkSync(tempPath);
+            return [{ data: buffer, type: mimeType, name: `clipboard-image.${extension}` }];
+        }
+        catch { }
+    }
+    // Fallback to pngpaste if available
+    try {
+        const tempPath = join(tmpdir(), `clipboard-${Date.now()}.png`);
+        await execAsync(`pngpaste "${tempPath}"`);
+        const buffer = readFileSync(tempPath);
+        unlinkSync(tempPath);
+        return [{ data: buffer, type: 'image/png', name: 'clipboard-image.png' }];
+    }
+    catch {
+        // No fallback worked
+    }
+    throw new Error('Unable to extract clipboard image on macOS');
+}
+async function getLinuxClipboardImage() {
+    const { stdout: targets } = await execAsync('xclip -selection clipboard -t TARGETS -o 2>/dev/null || echo ""');
+    const formats = [
+        { target: 'image/png', extension: 'png' },
+        { target: 'image/jpeg', extension: 'jpg' },
+        { target: 'image/gif', extension: 'gif' },
+        { target: 'image/bmp', extension: 'bmp' },
+        { target: 'image/tiff', extension: 'tiff' },
+        { target: 'image/webp', extension: 'webp' },
+    ];
+    for (const { target, extension } of formats) {
+        if (targets.includes(target)) {
+            try {
+                const { stdout: imageData } = await execAsync(`xclip -selection clipboard -t ${target} -o | base64`);
+                const buffer = Buffer.from(imageData.trim(), 'base64');
+                return [{ data: buffer, type: target, name: `clipboard-image.${extension}` }];
+            }
+            catch { }
+        }
+    }
+    throw new Error('No supported image format found in clipboard');
+}
+async function getWindowsClipboardImage() {
+    const tempPath = join(tmpdir(), `clipboard-${Date.now()}.png`);
+    try {
+        await execAsync(`powershell -command "
+      Add-Type -AssemblyName System.Windows.Forms
+      Add-Type -AssemblyName System.Drawing
+
+      if ([System.Windows.Forms.Clipboard]::ContainsImage()) {
+        $img = [System.Windows.Forms.Clipboard]::GetImage()
+        if ($img -ne $null) {
+          $img.Save('${tempPath.replace(/\\/g, '\\\\')}', [System.Drawing.Imaging.ImageFormat]::Png)
+          $img.Dispose()
+        }
+      }
+    "`);
+        const buffer = readFileSync(tempPath);
+        unlinkSync(tempPath);
+        return [{ data: buffer, type: 'image/png', name: 'clipboard-image.png' }];
+    }
+    catch (error) {
+        try {
+            unlinkSync(tempPath);
+        }
+        catch { }
+        throw error;
+    }
+}
+
+export { getClipboardFiles, hasClipboardFiles };

package/dist/demo-mode-Bop3nw4e.js

@@ -0,0 +1,112 @@
+import { A as AppContext, p as processMessageToUILines, r as render, j as jsxRuntimeExports, T as ThemeProvider, C as ConfigProvider, N as NotificationProvider, a as ToolApprovalProvider, b as CommandProvider, B as Box, c as ChatDisplay, I as InteractionArea, F as Footer, d as Text } from './cli-C9AKAZ8P.js';
+import { useContext, useEffect } from 'react';
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import 'meow';
+import 'node:fs';
+import 'node:os';
+import 'ansi-escapes';
+import 'node:crypto';
+import 'yaml';
+import 'ink-gradient';
+import 'node:child_process';
+import 'node:url';
+import 'open';
+import '@nuvin/nuvin-core';
+import 'node:buffer';
+import 'node:process';
+import 'react-reconciler';
+import 'yoga-layout';
+import 'ansi-regex';
+import 'node:events';
+import 'chalk';
+import 'marked';
+import 'supports-hyperlinks';
+import 'node-emoji';
+import 'cli-table3';
+import 'cli-highlight';
+import 'ink-spinner';
+import 'node:stream';
+import './_commonjsHelpers-BFTU3MAI.js';
+import 'events';
+import 'assert';
+import 'module';
+
+/**
+`useApp` is a React hook that exposes a method to manually exit the app (unmount).
+*/
+const useApp = () => useContext(AppContext);
+
+function DemoDisplayContent({ messages, metadata, messageCount }) {
+    const { exit } = useApp();
+    useEffect(() => {
+        const timer = setTimeout(() => {
+            exit();
+        }, 300);
+        return () => clearTimeout(timer);
+    }, [exit]);
+    return (jsxRuntimeExports.jsxs(Box, { flexDirection: "column", height: "100%", width: "100%", children: [jsxRuntimeExports.jsx(ChatDisplay, { messages: messages }, "demo"), jsxRuntimeExports.jsx(InteractionArea, { busy: false, vimModeEnabled: false, hasActiveCommand: false }), jsxRuntimeExports.jsx(Footer, { status: "Demo Mode", lastMetadata: metadata, toolApprovalMode: false, vimModeEnabled: false, vimMode: "insert", workingDirectory: process.cwd() }), jsxRuntimeExports.jsx(Box, { paddingX: 1, borderStyle: "single", borderColor: "yellow", marginTop: -1, children: jsxRuntimeExports.jsxs(Text, { color: "yellow", children: ["\uD83C\uDFA8 Demo Mode - Loaded ", messageCount, " messages - Auto-exiting in 3s..."] }) })] }));
+}
+// Mock config for demo
+const mockConfig = {
+    providers: {},
+    session: { memPersist: false },
+    requireToolApproval: false,
+};
+function DemoDisplay({ messages, metadata, messageCount }) {
+    return (jsxRuntimeExports.jsx(ThemeProvider, { children: jsxRuntimeExports.jsx(ConfigProvider, { initialConfig: mockConfig, children: jsxRuntimeExports.jsx(NotificationProvider, { children: jsxRuntimeExports.jsx(ToolApprovalProvider, { requireToolApproval: false, onError: (msg) => console.error(msg), children: jsxRuntimeExports.jsx(CommandProvider, { children: jsxRuntimeExports.jsx(DemoDisplayContent, { messages: messages, metadata: metadata, messageCount: messageCount }) }) }) }) }) }));
+}
+class DemoMode {
+    constructor(historyPath) {
+        this.historyPath = historyPath;
+    }
+    async run() {
+        try {
+            const resolvedPath = path.resolve(this.historyPath);
+            const fileContent = await fsp.readFile(resolvedPath, 'utf-8');
+            const historyData = JSON.parse(fileContent);
+            if (!historyData.cli || historyData.cli.length === 0) {
+                console.error('Error: No messages found in history file');
+                process.exit(1);
+            }
+            const cliMessages = historyData.cli;
+            const uiMessages = [];
+            for (const msg of cliMessages) {
+                uiMessages.push(...processMessageToUILines(msg));
+            }
+            let metadata = null;
+            for (let i = cliMessages.length - 1; i >= 0; i--) {
+                const msg = cliMessages[i];
+                if (msg.role === 'assistant') {
+                    metadata = {
+                        totalTokens: 0,
+                    };
+                    break;
+                }
+            }
+            console.clear();
+            console.log('\x1Bc');
+            const { waitUntilExit } = render(jsxRuntimeExports.jsx(DemoDisplay, { messages: uiMessages, metadata: metadata, messageCount: cliMessages.length }), {
+                exitOnCtrlC: true,
+                patchConsole: true,
+                maxFps: 30,
+            });
+            await waitUntilExit();
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                console.error(`Error: History file not found: ${this.historyPath}`);
+            }
+            else if (error instanceof SyntaxError) {
+                console.error(`Error: Invalid JSON in history file: ${this.historyPath}`);
+            }
+            else {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(`Error loading demo: ${message}`);
+            }
+            process.exit(1);
+        }
+    }
+}
+
+export { DemoMode };