@rawwee/interactive-mcp 1.0.0

package/dist/components/MarkdownText.js

@@ -0,0 +1,285 @@
+import { jsxs as _jsxs, jsx as _jsx } from "@opentui/react/jsx-runtime";
+import * as OpenTuiCore from '@opentui/core';
+import { createElement, useEffect, useMemo, useRef, useState } from 'react';
+import { copyTextToClipboard } from '../utils/clipboard.js';
+const { SyntaxStyle, RGBA } = OpenTuiCore;
+const CODE_BLOCK_REGEX = /```([^\n`]*)\n?([\s\S]*?)```/g;
+const DIFF_LANGUAGES = new Set(['diff', 'patch']);
+const LANGUAGE_TO_FILETYPE = {
+    js: 'javascript',
+    jsx: 'javascript',
+    ts: 'typescript',
+    tsx: 'tsx',
+    sh: 'bash',
+    shell: 'bash',
+    zsh: 'bash',
+    yml: 'yaml',
+    md: 'markdown',
+};
+function normalizeFiletype(language) {
+    if (!language) {
+        return undefined;
+    }
+    const normalized = language.trim().toLowerCase();
+    return LANGUAGE_TO_FILETYPE[normalized] ?? normalized;
+}
+function extractDiffFiletype(diffContent) {
+    const fileLineMatch = diffContent.match(/^(?:\+\+\+|---)\s+(?:[ab]\/)?(.+)$/m);
+    if (!fileLineMatch || !fileLineMatch[1]) {
+        return undefined;
+    }
+    const extensionMatch = fileLineMatch[1].match(/\.([a-zA-Z0-9]+)$/);
+    if (!extensionMatch || !extensionMatch[1]) {
+        return undefined;
+    }
+    return normalizeFiletype(extensionMatch[1]);
+}
+function isLikelyUnifiedDiff(content) {
+    const hasFileHeaders = /^---\s+/m.test(content) && /^\+\+\+\s+/m.test(content);
+    const hasHunkHeader = /^@@\s+/m.test(content);
+    const hasAddedOrRemovedLines = /^[+-](?![+-])\s?.+/m.test(content);
+    const hasGitHeader = /^diff --git\s+/m.test(content);
+    return ((hasFileHeaders || hasGitHeader || hasHunkHeader) && hasAddedOrRemovedLines);
+}
+function parseUnifiedDiff(content) {
+    const normalizedContent = content.replace(/\r\n/g, '\n');
+    const lines = normalizedContent.split('\n');
+    const oldLines = [];
+    const newLines = [];
+    const hunkLines = [];
+    let oldPath = 'a/file';
+    let newPath = 'b/file';
+    let inHunk = false;
+    let hasHunkContent = false;
+    for (const rawLine of lines) {
+        if (!inHunk) {
+            const oldPathMatch = rawLine.match(/^---\s+(.+)$/);
+            if (oldPathMatch) {
+                oldPath = oldPathMatch[1].split('\t')[0].trim() || oldPath;
+                continue;
+            }
+            const newPathMatch = rawLine.match(/^\+\+\+\s+(.+)$/);
+            if (newPathMatch) {
+                newPath = newPathMatch[1].split('\t')[0].trim() || newPath;
+                continue;
+            }
+        }
+        if (rawLine.startsWith('@@')) {
+            inHunk = true;
+            continue;
+        }
+        if (!inHunk) {
+            const startsLikeDiffLine = rawLine.startsWith('+') ||
+                rawLine.startsWith('-') ||
+                rawLine.startsWith(' ');
+            if (startsLikeDiffLine &&
+                !rawLine.startsWith('+++') &&
+                !rawLine.startsWith('---')) {
+                inHunk = true;
+            }
+            else {
+                continue;
+            }
+        }
+        if (rawLine === '\') {
+            continue;
+        }
+        if (rawLine.startsWith('+') && !rawLine.startsWith('+++')) {
+            const line = rawLine.slice(1);
+            newLines.push(line);
+            hunkLines.push(`+${line}`);
+            hasHunkContent = true;
+            continue;
+        }
+        if (rawLine.startsWith('-') && !rawLine.startsWith('---')) {
+            const line = rawLine.slice(1);
+            oldLines.push(line);
+            hunkLines.push(`-${line}`);
+            hasHunkContent = true;
+            continue;
+        }
+        if (rawLine.startsWith(' ')) {
+            const line = rawLine.slice(1);
+            oldLines.push(line);
+            newLines.push(line);
+            hunkLines.push(` ${line}`);
+            hasHunkContent = true;
+            continue;
+        }
+        if (rawLine.length === 0) {
+            continue;
+        }
+        return null;
+    }
+    if (!hasHunkContent) {
+        return null;
+    }
+    const oldCount = oldLines.length;
+    const newCount = newLines.length;
+    const unifiedDiff = [
+        `--- ${oldPath}`,
+        `+++ ${newPath}`,
+        `@@ -1,${oldCount} +1,${newCount} @@`,
+        ...hunkLines,
+    ].join('\n');
+    return {
+        oldCode: oldLines.join('\n'),
+        newCode: newLines.join('\n'),
+        unifiedDiff,
+    };
+}
+function splitMarkdownSegments(content) {
+    const segments = [];
+    let lastIndex = 0;
+    for (const match of content.matchAll(CODE_BLOCK_REGEX)) {
+        const [fullMatch, rawLanguage = '', rawCode = ''] = match;
+        if (typeof fullMatch !== 'string' || typeof match.index !== 'number') {
+            continue;
+        }
+        if (match.index > lastIndex) {
+            segments.push({
+                type: 'markdown',
+                value: content.slice(lastIndex, match.index),
+            });
+        }
+        segments.push({
+            type: 'code',
+            language: rawLanguage.trim() || undefined,
+            value: rawCode,
+        });
+        lastIndex = match.index + fullMatch.length;
+    }
+    if (lastIndex < content.length) {
+        segments.push({
+            type: 'markdown',
+            value: content.slice(lastIndex),
+        });
+    }
+    if (segments.length === 0) {
+        return [{ type: 'markdown', value: content }];
+    }
+    return segments;
+}
+export function MarkdownText({ content, streaming = false, showContentCopyControl = false, contentCopyLabel = 'Copy text', showCodeCopyControls = false, codeBlockMaxVisibleLines, }) {
+    const syntaxStyle = useMemo(() => {
+        const toColor = (hex) => typeof RGBA?.fromHex === 'function' ? RGBA.fromHex(hex) : hex;
+        if (typeof SyntaxStyle.fromStyles === 'function') {
+            return SyntaxStyle.fromStyles({
+                keyword: { fg: toColor('#FF7B72'), bold: true },
+                string: { fg: toColor('#A5D6FF') },
+                comment: { fg: toColor('#8B949E'), italic: true },
+                number: { fg: toColor('#79C0FF') },
+                function: { fg: toColor('#D2A8FF') },
+                type: { fg: toColor('#FFA657') },
+                operator: { fg: toColor('#FF7B72') },
+                property: { fg: toColor('#79C0FF') },
+                default: { fg: toColor('#E6EDF3') },
+            });
+        }
+        if (typeof SyntaxStyle.create === 'function') {
+            return SyntaxStyle.create();
+        }
+        return undefined;
+    }, []);
+    const segments = useMemo(() => splitMarkdownSegments(content), [content]);
+    const [clipboardHint, setClipboardHint] = useState(null);
+    const [copiedSnippetIndex, setCopiedSnippetIndex] = useState(null);
+    const copiedSnippetTimeoutRef = useRef(null);
+    useEffect(() => {
+        return () => {
+            if (copiedSnippetTimeoutRef.current) {
+                clearTimeout(copiedSnippetTimeoutRef.current);
+            }
+        };
+    }, []);
+    if (!content) {
+        return null;
+    }
+    const copyWithHint = async (value, successMessage) => {
+        if (!value) {
+            setClipboardHint('Nothing to copy.');
+            return;
+        }
+        try {
+            await copyTextToClipboard(value);
+            setClipboardHint(successMessage);
+        }
+        catch (error) {
+            setClipboardHint(`Copy failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
+    return (_jsxs("box", { flexDirection: "column", width: "100%", gap: 1, children: [showContentCopyControl && (_jsx("box", { width: "100%", justifyContent: "flex-end", children: _jsxs("text", { fg: "cyan", onMouseUp: () => {
+                        void copyWithHint(content, 'Prompt copied to clipboard.');
+                    }, children: ["[", contentCopyLabel, "]"] }) })), segments.map((segment, index) => {
+                if (segment.type === 'markdown') {
+                    if (!segment.value.trim()) {
+                        return _jsx("box", {}, `segment-${index}`);
+                    }
+                    return (_jsx("markdown", { content: segment.value, syntaxStyle: syntaxStyle, conceal: true, streaming: streaming }, `segment-${index}`));
+                }
+                const normalizedLanguage = normalizeFiletype(segment.language);
+                const isDiffSegment = normalizedLanguage !== undefined &&
+                    DIFF_LANGUAGES.has(normalizedLanguage);
+                const lineCount = segment.value.split('\n').length;
+                const shouldLimitCodeHeight = typeof codeBlockMaxVisibleLines === 'number' &&
+                    codeBlockMaxVisibleLines > 0 &&
+                    lineCount > codeBlockMaxVisibleLines;
+                const parsedDiff = isDiffSegment
+                    ? parseUnifiedDiff(segment.value)
+                    : null;
+                const diffLanguage = extractDiffFiletype(segment.value);
+                const codeProps = {
+                    code: segment.value,
+                    language: normalizedLanguage,
+                    content: segment.value,
+                    filetype: normalizedLanguage,
+                    syntaxStyle: syntaxStyle,
+                    conceal: true,
+                    streaming,
+                    wrapMode: 'word',
+                    width: '100%',
+                };
+                const codeElement = createElement('code', codeProps);
+                const codeRenderable = codeElement;
+                const diffProps = parsedDiff
+                    ? {
+                        oldCode: parsedDiff.oldCode,
+                        newCode: parsedDiff.newCode,
+                        language: diffLanguage,
+                        mode: 'unified',
+                        diff: parsedDiff.unifiedDiff,
+                        view: 'unified',
+                        filetype: diffLanguage,
+                        syntaxStyle: syntaxStyle,
+                        showLineNumbers: true,
+                        conceal: true,
+                        wrapMode: 'word',
+                        width: '100%',
+                    }
+                    : null;
+                const diffRenderable = parsedDiff
+                    ? createElement('diff', diffProps)
+                    : null;
+                const codeDescription = isDiffSegment
+                    ? 'Diff snippet'
+                    : normalizedLanguage
+                        ? `${normalizedLanguage} snippet`
+                        : 'Code snippet';
+                const shouldRenderDiff = isDiffSegment && isLikelyUnifiedDiff(segment.value) && diffRenderable;
+                const snippetRenderable = shouldRenderDiff
+                    ? diffRenderable
+                    : codeRenderable;
+                return (_jsxs("box", { flexDirection: "column", width: "100%", children: [showCodeCopyControls && (_jsxs("box", { width: "100%", justifyContent: "space-between", children: [_jsx("text", { fg: "gray", children: codeDescription }), _jsxs("text", { fg: "cyan", onMouseUp: () => {
+                                        setCopiedSnippetIndex(index);
+                                        if (copiedSnippetTimeoutRef.current) {
+                                            clearTimeout(copiedSnippetTimeoutRef.current);
+                                        }
+                                        copiedSnippetTimeoutRef.current = setTimeout(() => {
+                                            setCopiedSnippetIndex((currentIndex) => currentIndex === index ? null : currentIndex);
+                                        }, 1200);
+                                        void copyWithHint(segment.value, 'Code snippet copied to clipboard.');
+                                    }, children: ["[", copiedSnippetIndex === index ? 'Copied!' : 'Copy code', "]"] })] })), _jsx("box", { width: "100%", border: true, borderStyle: "single", borderColor: "gray", paddingLeft: 1, marginLeft: 1, children: shouldLimitCodeHeight ? (_jsx("scrollbox", { width: "100%", height: codeBlockMaxVisibleLines, scrollY: true, viewportCulling: false, scrollbarOptions: {
+                                    showArrows: false,
+                                }, children: snippetRenderable })) : (snippetRenderable) })] }, `segment-${index}`));
+            }), clipboardHint && _jsx("text", { fg: "gray", children: clipboardHint })] }));
+}

package/dist/components/PromptStatus.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+import * as OpenTuiReact from '@opentui/react';
+import { useEffect, useState } from 'react';
+import { TextProgressBar } from './TextProgressBar.js';
+const { useTerminalDimensions } = OpenTuiReact;
+const { useTimeline } = OpenTuiReact;
+export function PromptStatus({ value, timeLeftSeconds, critical, }) {
+    const { width } = useTerminalDimensions();
+    const [pulseLevel, setPulseLevel] = useState(0);
+    const timeline = useTimeline({ duration: 900, loop: true, autoplay: false });
+    const suffixLength = ` • ${timeLeftSeconds}s left`.length;
+    const availableWidth = Math.max(16, width - 4);
+    const reservedWidth = 2 + 1 + 4 + suffixLength;
+    const computedBarWidth = availableWidth - reservedWidth;
+    const barWidth = Math.max(6, Math.min(28, computedBarWidth));
+    const shortcutHint = width < 80 ? '⌃S send • ⇧↹ mode' : '⌃S send • ⇥ mode • ⇧↹ reverse';
+    useEffect(() => {
+        if (!critical) {
+            timeline.pause();
+            timeline.resetItems();
+            setPulseLevel(0);
+            return;
+        }
+        const pulseTarget = { level: 0 };
+        timeline.resetItems();
+        timeline.add(pulseTarget, {
+            level: 1,
+            duration: 900,
+            ease: 'inOutSine',
+            loop: true,
+            alternate: true,
+            onUpdate: (animation) => {
+                const nextValue = animation.targets[0]?.level;
+                if (typeof nextValue === 'number') {
+                    setPulseLevel(nextValue);
+                }
+            },
+        });
+        timeline.play();
+        return () => {
+            timeline.pause();
+            timeline.resetItems();
+        };
+    }, [critical, timeline]);
+    return (_jsxs("box", { flexDirection: "column", alignItems: "flex-start", width: "100%", gap: 0, children: [_jsx("text", { fg: "gray", wrapMode: "word", children: shortcutHint }), _jsxs("text", { fg: critical && pulseLevel > 0.5 ? 'red' : 'gray', children: [critical ? '●' : '○', " ", timeLeftSeconds, "s remaining"] }), _jsx(TextProgressBar, { value: value, width: barWidth, timeLeftSeconds: timeLeftSeconds, critical: critical })] }));
+}

package/dist/components/TextProgressBar.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "@opentui/react/jsx-runtime";
+export function TextProgressBar({ value, width = 28, timeLeftSeconds, critical = false, }) {
+    const clamped = Number.isFinite(value)
+        ? Math.max(0, Math.min(100, value))
+        : 0;
+    const filledWidth = Math.round((clamped / 100) * width);
+    const bar = `${'█'.repeat(filledWidth)}${'░'.repeat(width - filledWidth)}`;
+    const suffix = typeof timeLeftSeconds === 'number' ? ` • ${timeLeftSeconds}s left` : '';
+    return (_jsx("text", { fg: critical ? 'red' : 'yellow', children: `[${bar}] ${Math.round(clamped)}%${suffix}` }));
+}

package/dist/components/interactive-input/autocomplete.js

@@ -0,0 +1,127 @@
+import fs from 'fs/promises';
+import path from 'path';
+const IGNORED_DIRECTORIES = new Set([
+    '.git',
+    'node_modules',
+    'dist',
+    'build',
+    '.next',
+    '.turbo',
+    '.idea',
+    '.vscode',
+    '.DS_Store',
+]);
+const MAX_REPOSITORY_FILES = 6000;
+const MAX_SUGGESTIONS = 6;
+const toPosixPath = (value) => value.replaceAll(path.sep, '/');
+const getFuzzyScore = (candidate, query) => {
+    const candidateLower = candidate.toLowerCase();
+    const queryLower = query.toLowerCase();
+    if (candidateLower.includes(queryLower)) {
+        const index = candidateLower.indexOf(queryLower);
+        const startsWithBonus = index === 0 ? 20 : 0;
+        return 1000 - index * 5 - candidate.length + startsWithBonus;
+    }
+    let queryIndex = 0;
+    let score = 0;
+    let runLength = 0;
+    for (let i = 0; i < candidateLower.length && queryIndex < queryLower.length; i++) {
+        if (candidateLower[i] === queryLower[queryIndex]) {
+            queryIndex += 1;
+            runLength += 1;
+            score += 2 + runLength;
+        }
+        else {
+            runLength = 0;
+            score -= 0.2;
+        }
+    }
+    if (queryIndex !== queryLower.length) {
+        return null;
+    }
+    return score - candidate.length * 0.1;
+};
+export const getAutocompleteTarget = (value, caret) => {
+    const clampedCaret = Math.max(0, Math.min(caret, value.length));
+    let start = clampedCaret;
+    const separators = new Set([' ', '\n', '\t', '"', "'", '(', ')', '[', ']']);
+    const isWhitespace = (character) => character === ' ' || character === '\n' || character === '\t';
+    while (start > 0 && !separators.has(value[start - 1])) {
+        start -= 1;
+    }
+    const token = value.slice(start, clampedCaret);
+    if (token.startsWith('#')) {
+        return {
+            start,
+            end: clampedCaret,
+            query: token.slice(1),
+        };
+    }
+    let probe = start;
+    while (probe > 0 && isWhitespace(value[probe - 1])) {
+        probe -= 1;
+    }
+    if (probe <= 0 || value[probe - 1] !== '#') {
+        return null;
+    }
+    const hashIndex = probe - 1;
+    if (hashIndex > 0 && !separators.has(value[hashIndex - 1])) {
+        return null;
+    }
+    return {
+        start: hashIndex,
+        end: clampedCaret,
+        query: value.slice(hashIndex + 1, clampedCaret).trimStart(),
+    };
+};
+export const rankFileSuggestions = (files, query) => {
+    if (query.length === 0) {
+        return files.slice(0, MAX_SUGGESTIONS);
+    }
+    return files
+        .map((filePath) => ({
+        filePath,
+        score: getFuzzyScore(filePath, query),
+    }))
+        .filter((entry) => typeof entry.score === 'number')
+        .sort((a, b) => b.score - a.score || a.filePath.localeCompare(b.filePath))
+        .slice(0, MAX_SUGGESTIONS)
+        .map((entry) => entry.filePath);
+};
+export const readRepositoryFiles = async (repoRoot) => {
+    const discoveredFiles = [];
+    const visitDirectory = async (directoryPath) => {
+        if (discoveredFiles.length >= MAX_REPOSITORY_FILES) {
+            return;
+        }
+        let entries = [];
+        try {
+            entries = await fs.readdir(directoryPath, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (discoveredFiles.length >= MAX_REPOSITORY_FILES) {
+                return;
+            }
+            if (IGNORED_DIRECTORIES.has(entry.name)) {
+                continue;
+            }
+            const entryAbsolutePath = path.join(directoryPath, entry.name);
+            if (entry.isDirectory()) {
+                await visitDirectory(entryAbsolutePath);
+                continue;
+            }
+            if (entry.isFile()) {
+                const relativePath = path.relative(repoRoot, entryAbsolutePath);
+                if (!relativePath || relativePath.startsWith('..')) {
+                    continue;
+                }
+                discoveredFiles.push(toPosixPath(relativePath));
+            }
+        }
+    };
+    await visitDirectory(repoRoot);
+    return discoveredFiles.sort((a, b) => a.localeCompare(b));
+};

package/dist/components/interactive-input/keyboard.js

@@ -0,0 +1,51 @@
+const CTRL_MODIFIED_KEY_CSI_U_SEQUENCE = new RegExp(`^${String.fromCharCode(27)}\\[(\\d+);(\\d+)u$`);
+const hasCtrlOrMetaModifier = (modifierCode) => {
+    const modifierFlags = modifierCode - 1;
+    const includesCtrl = (modifierFlags & 4) !== 0;
+    const includesMeta = (modifierFlags & 8) !== 0;
+    return includesCtrl || includesMeta;
+};
+export const isControlKeyShortcut = (key, letter) => {
+    const lowerName = key.name.toLowerCase();
+    if ((key.ctrl || key.meta) && lowerName === letter) {
+        return true;
+    }
+    const csiUMatch = key.sequence.match(CTRL_MODIFIED_KEY_CSI_U_SEQUENCE);
+    if (!csiUMatch) {
+        return false;
+    }
+    const keyCode = Number(csiUMatch[1]);
+    const modifierCode = Number(csiUMatch[2]);
+    const lowercaseKeyCode = letter.charCodeAt(0);
+    const uppercaseKeyCode = letter.toUpperCase().charCodeAt(0);
+    return ((keyCode === lowercaseKeyCode || keyCode === uppercaseKeyCode) &&
+        hasCtrlOrMetaModifier(modifierCode));
+};
+export const isSubmitShortcut = (key) => isControlKeyShortcut(key, 's');
+export const isReverseTabShortcut = (key) => key.name === 'backtab' ||
+    (key.name === 'tab' && key.shift) ||
+    key.sequence === '\u001b[Z';
+export const isPrintableCharacter = (key) => {
+    if (key.ctrl || key.meta || key.option || key.name === 'tab') {
+        return null;
+    }
+    if (key.name === 'space') {
+        return ' ';
+    }
+    if (key.sequence.length === 1 && key.sequence >= ' ') {
+        return key.sequence;
+    }
+    if (key.name.length === 1) {
+        return key.shift ? key.name.toUpperCase() : key.name;
+    }
+    return null;
+};
+export const textareaKeyBindings = [
+    { name: 's', ctrl: true, action: 'submit' },
+    { name: 's', meta: true, action: 'submit' },
+    { name: 's', super: true, action: 'submit' },
+    { name: 'a', ctrl: true, action: 'select-all' },
+    { name: 'a', meta: true, action: 'select-all' },
+    { name: 'a', super: true, action: 'select-all' },
+    { name: 'j', ctrl: true, action: 'newline' },
+];

package/dist/components/interactive-input/types.js

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

package/dist/constants.js

@@ -0,0 +1,13 @@
+/**
+ * Shared constants for the application.
+ */
+/**
+ * Timeout duration in seconds for waiting for user input in both single-input and intensive chat modes.
+ * This aligns with the default timeout expected by the MCP tool.
+ */
+export const USER_INPUT_TIMEOUT_SECONDS = 60;
+/**
+ * Sentinel string written by UI processes when a prompt times out.
+ * This should be handled consistently across command and tool layers.
+ */
+export const USER_INPUT_TIMEOUT_SENTINEL = '__TIMEOUT__';