@mcp-use/cli 1.0.0 → 1.0.1

package/dist/SimpleMultilineInput.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface SimpleMultilineInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit: (value: string) => void;
+    placeholder?: string;
+    mask?: string;
+    focus?: boolean;
+}
+export declare const SimpleMultilineInput: React.FC<SimpleMultilineInputProps>;
+export {};

package/dist/SimpleMultilineInput.js

@@ -0,0 +1,125 @@
+import React, { useState, useEffect, useCallback } from 'react';
+import { Box, Text, useInput } from 'ink';
+export const SimpleMultilineInput = ({ value, onChange, onSubmit, placeholder = '', mask, focus = true }) => {
+    const [cursorPosition, setCursorPosition] = useState(value.length);
+    const [lines, setLines] = useState([]);
+    // Update lines when value changes
+    useEffect(() => {
+        const newLines = value.split('\n');
+        setLines(newLines);
+        setCursorPosition(value.length);
+    }, [value]);
+    // Calculate cursor position in 2D space
+    const getCursorCoords = useCallback(() => {
+        let pos = 0;
+        for (let row = 0; row < lines.length; row++) {
+            const lineLength = lines[row]?.length || 0;
+            if (pos + lineLength >= cursorPosition) {
+                return [row, cursorPosition - pos];
+            }
+            pos += lineLength + 1; // +1 for newline
+        }
+        return [lines.length - 1, lines[lines.length - 1]?.length || 0];
+    }, [lines, cursorPosition]);
+    useInput((input, key) => {
+        if (!focus)
+            return;
+        // Submit on Enter
+        if (key.return && !key.ctrl && !key.meta) {
+            onSubmit(value);
+            return;
+        }
+        // New line on Ctrl+Enter or Meta+Enter
+        if (key.return && (key.ctrl || key.meta)) {
+            const beforeCursor = value.slice(0, cursorPosition);
+            const afterCursor = value.slice(cursorPosition);
+            onChange(beforeCursor + '\n' + afterCursor);
+            setCursorPosition(cursorPosition + 1);
+            return;
+        }
+        // Backspace
+        if (key.backspace || key.delete) {
+            if (cursorPosition > 0) {
+                const beforeCursor = value.slice(0, cursorPosition - 1);
+                const afterCursor = value.slice(cursorPosition);
+                onChange(beforeCursor + afterCursor);
+                setCursorPosition(cursorPosition - 1);
+            }
+            return;
+        }
+        // Left arrow
+        if (key.leftArrow) {
+            setCursorPosition(Math.max(0, cursorPosition - 1));
+            return;
+        }
+        // Right arrow
+        if (key.rightArrow) {
+            setCursorPosition(Math.min(value.length, cursorPosition + 1));
+            return;
+        }
+        // Up arrow - move cursor up
+        if (key.upArrow) {
+            const [row, col] = getCursorCoords();
+            if (row > 0) {
+                const prevLineLength = lines[row - 1]?.length || 0;
+                const newCol = Math.min(col, prevLineLength);
+                let newPos = 0;
+                for (let i = 0; i < row - 1; i++) {
+                    newPos += (lines[i]?.length || 0) + 1;
+                }
+                newPos += newCol;
+                setCursorPosition(newPos);
+            }
+            return;
+        }
+        // Down arrow - move cursor down
+        if (key.downArrow) {
+            const [row, col] = getCursorCoords();
+            if (row < lines.length - 1) {
+                const nextLineLength = lines[row + 1]?.length || 0;
+                const newCol = Math.min(col, nextLineLength);
+                let newPos = 0;
+                for (let i = 0; i <= row; i++) {
+                    newPos += (lines[i]?.length || 0) + 1;
+                }
+                newPos += newCol;
+                setCursorPosition(newPos);
+            }
+            return;
+        }
+        // Regular character input
+        if (input && !key.ctrl && !key.meta) {
+            const beforeCursor = value.slice(0, cursorPosition);
+            const afterCursor = value.slice(cursorPosition);
+            onChange(beforeCursor + input + afterCursor);
+            setCursorPosition(cursorPosition + input.length);
+        }
+    });
+    // Render the input
+    const renderContent = () => {
+        if (!value && placeholder && !focus) {
+            return React.createElement(Text, { dimColor: true }, placeholder);
+        }
+        const [cursorRow, cursorCol] = getCursorCoords();
+        return lines.map((line, row) => {
+            let displayLine = mask ? line.replace(/./g, mask) : line;
+            // Add cursor to the current line
+            if (row === cursorRow && focus) {
+                const before = displayLine.slice(0, cursorCol);
+                const at = displayLine[cursorCol] || ' ';
+                const after = displayLine.slice(cursorCol + 1);
+                return (React.createElement(Box, { key: row },
+                    React.createElement(Text, null,
+                        before,
+                        React.createElement(Text, { inverse: true }, at),
+                        after)));
+            }
+            return React.createElement(Box, { key: row },
+                React.createElement(Text, null, displayLine || ' '));
+        });
+    };
+    return (React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+        renderContent(),
+        focus && lines.length > 1 && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true, italic: true }, "Ctrl+Enter for new line, Enter to submit")))));
+};

package/dist/app.d.ts

@@ -1,6 +1,2 @@
 import React from 'react';
-type Props = {
-    name?: string;
-};
-export default function App({ name }: Props): React.JSX.Element;
-export {};
+export default function App(): React.JSX.Element;