dbctx 1.4.5 → 1.5.0

package/dist/ui/components/TextInput.js

@@ -0,0 +1,286 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import { useState, useEffect, useRef } from 'react';
+const CURSOR_INTERVAL = 500;
+const MAX_UNDO = 100;
+const UNDO_GROUP_DELAY = 2500;
+const findLineStart = (value, cursor) => {
+    const idx = value.lastIndexOf('\n', cursor - 1);
+    return idx === -1 ? 0 : idx + 1;
+};
+const findLineEnd = (value, cursor) => {
+    const idx = value.indexOf('\n', cursor);
+    return idx === -1 ? value.length : idx;
+};
+const findPrevWordBoundary = (value, cursor) => {
+    const lineStart = findLineStart(value, cursor);
+    let pos = cursor - 1;
+    while (pos > lineStart && /\s/.test(value[pos]) && value[pos] !== '\n') {
+        pos -= 1;
+    }
+    while (pos > lineStart && !/\s/.test(value[pos - 1])) {
+        pos -= 1;
+    }
+    return Math.max(lineStart, pos);
+};
+const findNextWordBoundary = (value, cursor) => {
+    const lineEnd = findLineEnd(value, cursor);
+    let pos = cursor;
+    while (pos < lineEnd && !/\s/.test(value[pos])) {
+        pos += 1;
+    }
+    while (pos < lineEnd && /\s/.test(value[pos]) && value[pos] !== '\n') {
+        pos += 1;
+    }
+    return Math.min(lineEnd, pos);
+};
+const getCursorLineAndColumn = (value, cursor) => {
+    let line = 0;
+    let lastLineStart = 0;
+    for (let i = 0; i < cursor; i++) {
+        if (value[i] === '\n') {
+            line += 1;
+            lastLineStart = i + 1;
+        }
+    }
+    return { line, column: cursor - lastLineStart };
+};
+export const TextInput = ({ isActive, onSubmit, placeholder, linePrefix, }) => {
+    const [value, setValue] = useState('');
+    const [cursor, setCursor] = useState(0);
+    const [cursorVisible, setCursorVisible] = useState(true);
+    useEffect(() => {
+        if (!isActive) {
+            return;
+        }
+        const id = setInterval(() => {
+            setCursorVisible((prev) => !prev);
+        }, CURSOR_INTERVAL);
+        return () => {
+            clearInterval(id);
+        };
+    }, [isActive]);
+    const undoStack = useRef([]);
+    const lastMutationTime = useRef(0);
+    const lastMutationType = useRef(null);
+    const resetBlink = () => {
+        setCursorVisible(true);
+    };
+    const pushUndo = (type) => {
+        const now = Date.now();
+        const elapsed = now - lastMutationTime.current;
+        const sameType = type === lastMutationType.current;
+        lastMutationTime.current = now;
+        lastMutationType.current = type;
+        if (elapsed < UNDO_GROUP_DELAY && sameType) {
+            return;
+        }
+        const stack = undoStack.current;
+        if (stack.length >= MAX_UNDO) {
+            stack.shift();
+        }
+        stack.push({ value, cursor });
+    };
+    useInput((input, key) => {
+        // Ctrl+J — insert newline
+        if (key.ctrl && input === 'j') {
+            resetBlink();
+            pushUndo('insert');
+            setValue((v) => v.slice(0, cursor) + '\n' + v.slice(cursor));
+            setCursor((c) => c + 1);
+            return;
+        }
+        // Enter — submit
+        if (key.return) {
+            onSubmit(value);
+            return;
+        }
+        // Up arrow — move to same column on previous line
+        if (key.upArrow) {
+            resetBlink();
+            setCursor((c) => {
+                const { line, column } = getCursorLineAndColumn(value, c);
+                if (line === 0) {
+                    return findLineStart(value, c);
+                }
+                const prevLineEnd = findLineStart(value, c) - 1;
+                const prevLineStart = findLineStart(value, prevLineEnd);
+                const prevLineLength = prevLineEnd - prevLineStart;
+                return prevLineStart + Math.min(column, prevLineLength);
+            });
+            return;
+        }
+        // Down arrow — move to next line, or create one if on last line
+        if (key.downArrow) {
+            resetBlink();
+            const currentLineEnd = findLineEnd(value, cursor);
+            if (currentLineEnd >= value.length) {
+                // On last line — insert a new line and move cursor there
+                pushUndo('insert');
+                setValue((v) => v + '\n');
+                setCursor(value.length + 1);
+            }
+            else {
+                setCursor((c) => {
+                    const { column } = getCursorLineAndColumn(value, c);
+                    const nextLineStart = currentLineEnd + 1;
+                    const nextLineEnd = findLineEnd(value, nextLineStart);
+                    const nextLineLength = nextLineEnd - nextLineStart;
+                    return nextLineStart + Math.min(column, nextLineLength);
+                });
+            }
+            return;
+        }
+        // Left arrow
+        if (key.leftArrow) {
+            resetBlink();
+            setCursor((c) => Math.max(0, c - 1));
+            return;
+        }
+        // Right arrow
+        if (key.rightArrow) {
+            resetBlink();
+            setCursor((c) => Math.min(value.length, c + 1));
+            return;
+        }
+        // Opt+Left (meta+b) — word jump backward
+        if (key.meta && input === 'b') {
+            resetBlink();
+            setCursor((c) => findPrevWordBoundary(value, c));
+            return;
+        }
+        // Opt+Right (meta+f) — word jump forward
+        if (key.meta && input === 'f') {
+            resetBlink();
+            setCursor((c) => findNextWordBoundary(value, c));
+            return;
+        }
+        // Ctrl+A — start of current line
+        if (key.ctrl && input === 'a') {
+            resetBlink();
+            setCursor((c) => findLineStart(value, c));
+            return;
+        }
+        // Ctrl+E — end of current line
+        if (key.ctrl && input === 'e') {
+            resetBlink();
+            setCursor((c) => findLineEnd(value, c));
+            return;
+        }
+        // Ctrl+W — delete word before cursor
+        if (key.ctrl && input === 'w') {
+            resetBlink();
+            pushUndo('delete');
+            setCursor((c) => {
+                const boundary = findPrevWordBoundary(value, c);
+                setValue((v) => v.slice(0, boundary) + v.slice(c));
+                return boundary;
+            });
+            return;
+        }
+        // Ctrl+U — delete to start of current line
+        if (key.ctrl && input === 'u') {
+            resetBlink();
+            pushUndo('delete');
+            setCursor((c) => {
+                const lineStart = findLineStart(value, c);
+                setValue((v) => v.slice(0, lineStart) + v.slice(c));
+                return lineStart;
+            });
+            return;
+        }
+        // Ctrl+K — delete to end of current line
+        if (key.ctrl && input === 'k') {
+            resetBlink();
+            pushUndo('delete');
+            setCursor((c) => {
+                const lineEnd = findLineEnd(value, c);
+                setValue((v) => v.slice(0, c) + v.slice(lineEnd));
+                return c;
+            });
+            return;
+        }
+        // Backspace (with Opt+Backspace for word deletion)
+        if (key.backspace || key.delete) {
+            if (key.meta) {
+                // Opt+Delete — delete word before cursor
+                resetBlink();
+                pushUndo('delete');
+                const boundary = findPrevWordBoundary(value, cursor);
+                setValue((v) => v.slice(0, boundary) + v.slice(cursor));
+                setCursor(boundary);
+                return;
+            }
+            if (cursor > 0) {
+                resetBlink();
+                pushUndo('delete');
+                setValue((v) => v.slice(0, cursor - 1) + v.slice(cursor));
+                setCursor((c) => c - 1);
+            }
+            return;
+        }
+        // Ctrl+Z — undo
+        if (key.ctrl && input === 'z') {
+            resetBlink();
+            const entry = undoStack.current.pop();
+            if (entry) {
+                setValue(entry.value);
+                setCursor(entry.cursor);
+            }
+            lastMutationTime.current = 0;
+            lastMutationType.current = null;
+            return;
+        }
+        // Ignore other control/meta/escape/tab keys
+        if (key.ctrl || key.escape || key.tab) {
+            return;
+        }
+        // Regular character input
+        if (input && input.length > 0) {
+            resetBlink();
+            pushUndo('insert');
+            setValue((v) => v.slice(0, cursor) + input + v.slice(cursor));
+            setCursor((c) => c + input.length);
+        }
+    }, { isActive });
+    const renderLine = (content, key, lineNumber, totalLines) => {
+        const prefix = typeof linePrefix === 'function'
+            ? linePrefix(lineNumber, totalLines)
+            : linePrefix;
+        return prefix ? (_jsxs(Box, { children: [prefix, content] }, key)) : (_jsx(Box, { children: content }, key));
+    };
+    // Render placeholder when empty and not focused
+    if (value.length === 0 && !isActive && placeholder) {
+        return (_jsxs(Box, { flexDirection: "column", children: [renderLine(_jsx(Text, { dimColor: true, children: placeholder }), 0, 0, 2), renderLine(_jsx(Text, { children: " " }), 1, 1, 2)] }));
+    }
+    // Render placeholder with cursor when empty and focused
+    if (value.length === 0 && isActive) {
+        return (_jsxs(Box, { flexDirection: "column", children: [renderLine(_jsxs(Text, { children: [cursorVisible ? '\x1b[7m \x1b[27m' : ' ', placeholder ? (_jsx(Text, { dimColor: true, children: placeholder })) : null] }), 0, 0, 2), renderLine(_jsx(Text, { children: " " }), 1, 1, 2)] }));
+    }
+    // Multi-line rendering (minimum 2 visible lines)
+    const lines = value.split('\n');
+    const totalLines = Math.max(lines.length, 2);
+    const hasContent = value.replace(/\n/g, '').length > 0;
+    const { line: cursorLine, column: cursorColumn } = getCursorLineAndColumn(value, cursor);
+    const renderedLines = lines.map((lineText, lineIdx) => {
+        const isCursorLine = lineIdx === cursorLine;
+        if (!isCursorLine || !isActive) {
+            return renderLine(_jsxs(Text, { children: [lineText || ' ', lineIdx === 0 && !hasContent && placeholder ? (_jsx(Text, { dimColor: true, children: placeholder })) : null] }), lineIdx, lineIdx, totalLines);
+        }
+        const before = lineText.slice(0, cursorColumn);
+        const atCursor = lineText[cursorColumn] ?? ' ';
+        const after = lineText.slice(cursorColumn + 1);
+        return renderLine(_jsxs(Text, { children: [before, cursorVisible
+                    ? `\x1b[7m${atCursor}\x1b[27m`
+                    : atCursor === ' ' && cursorColumn >= lineText.length
+                        ? ' '
+                        : atCursor, after, lineIdx === 0 && !hasContent && placeholder ? (_jsx(Text, { dimColor: true, children: placeholder })) : null] }), lineIdx, lineIdx, totalLines);
+    });
+    // Pad to minimum 2 lines so the input visually signals multi-line
+    while (renderedLines.length < 2) {
+        const padIdx = renderedLines.length;
+        renderedLines.push(renderLine(_jsx(Text, { children: " " }), `pad-${padIdx}`, padIdx, totalLines));
+    }
+    return _jsx(Box, { flexDirection: "column", children: renderedLines });
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TextInput.js","sourceRoot":"./src/","sources":["ui/components/TextInput.tsx"],"names":[],"mappings":"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","sourcesContent":["import {Box, Text, useInput} from 'ink';\nimport type {ReactNode} from 'react';\nimport {useState, useEffect, useRef} from 'react';\n\nconst CURSOR_INTERVAL = 500;\nconst MAX_UNDO = 100;\nconst UNDO_GROUP_DELAY = 2500;\n\ntype TUndoEntry = {readonly value: string; readonly cursor: number};\ntype TMutationType = 'insert' | 'delete';\n\nconst findLineStart = (value: string, cursor: number): number => {\n    const idx = value.lastIndexOf('\\n', cursor - 1);\n    return idx === -1 ? 0 : idx + 1;\n};\n\nconst findLineEnd = (value: string, cursor: number): number => {\n    const idx = value.indexOf('\\n', cursor);\n    return idx === -1 ? value.length : idx;\n};\n\nconst findPrevWordBoundary = (value: string, cursor: number): number => {\n    const lineStart = findLineStart(value, cursor);\n    let pos = cursor - 1;\n    while (pos > lineStart && /\\s/.test(value[pos]!) && value[pos] !== '\\n') {\n        pos -= 1;\n    }\n    while (pos > lineStart && !/\\s/.test(value[pos - 1]!)) {\n        pos -= 1;\n    }\n    return Math.max(lineStart, pos);\n};\n\nconst findNextWordBoundary = (value: string, cursor: number): number => {\n    const lineEnd = findLineEnd(value, cursor);\n    let pos = cursor;\n    while (pos < lineEnd && !/\\s/.test(value[pos]!)) {\n        pos += 1;\n    }\n    while (pos < lineEnd && /\\s/.test(value[pos]!) && value[pos] !== '\\n') {\n        pos += 1;\n    }\n    return Math.min(lineEnd, pos);\n};\n\nconst getCursorLineAndColumn = (\n    value: string,\n    cursor: number,\n): {line: number; column: number} => {\n    let line = 0;\n    let lastLineStart = 0;\n    for (let i = 0; i < cursor; i++) {\n        if (value[i] === '\\n') {\n            line += 1;\n            lastLineStart = i + 1;\n        }\n    }\n    return {line, column: cursor - lastLineStart};\n};\n\ntype TLinePrefixFn = (lineNumber: number, totalLines: number) => ReactNode;\n\ntype TTextInputProps = {\n    readonly isActive: boolean;\n    readonly onSubmit: (value: string) => void;\n    readonly placeholder?: string;\n    readonly linePrefix?: ReactNode | TLinePrefixFn;\n};\n\nexport const TextInput = ({\n    isActive,\n    onSubmit,\n    placeholder,\n    linePrefix,\n}: TTextInputProps): ReactNode => {\n    const [value, setValue] = useState('');\n    const [cursor, setCursor] = useState(0);\n    const [cursorVisible, setCursorVisible] = useState(true);\n\n    useEffect(() => {\n        if (!isActive) {\n            return;\n        }\n\n        const id = setInterval(() => {\n            setCursorVisible((prev) => !prev);\n        }, CURSOR_INTERVAL);\n\n        return () => {\n            clearInterval(id);\n        };\n    }, [isActive]);\n\n    const undoStack = useRef<TUndoEntry[]>([]);\n    const lastMutationTime = useRef(0);\n    const lastMutationType = useRef<TMutationType | null>(null);\n\n    const resetBlink = () => {\n        setCursorVisible(true);\n    };\n\n    const pushUndo = (type: TMutationType) => {\n        const now = Date.now();\n        const elapsed = now - lastMutationTime.current;\n        const sameType = type === lastMutationType.current;\n\n        lastMutationTime.current = now;\n        lastMutationType.current = type;\n\n        if (elapsed < UNDO_GROUP_DELAY && sameType) {\n            return;\n        }\n\n        const stack = undoStack.current;\n        if (stack.length >= MAX_UNDO) {\n            stack.shift();\n        }\n        stack.push({value, cursor});\n    };\n\n    useInput(\n        (input, key) => {\n            // Ctrl+J — insert newline\n            if (key.ctrl && input === 'j') {\n                resetBlink();\n                pushUndo('insert');\n                setValue((v) => v.slice(0, cursor) + '\\n' + v.slice(cursor));\n                setCursor((c) => c + 1);\n                return;\n            }\n\n            // Enter — submit\n            if (key.return) {\n                onSubmit(value);\n                return;\n            }\n\n            // Up arrow — move to same column on previous line\n            if (key.upArrow) {\n                resetBlink();\n                setCursor((c) => {\n                    const {line, column} = getCursorLineAndColumn(value, c);\n                    if (line === 0) {\n                        return findLineStart(value, c);\n                    }\n                    const prevLineEnd = findLineStart(value, c) - 1;\n                    const prevLineStart = findLineStart(value, prevLineEnd);\n                    const prevLineLength = prevLineEnd - prevLineStart;\n                    return prevLineStart + Math.min(column, prevLineLength);\n                });\n                return;\n            }\n\n            // Down arrow — move to next line, or create one if on last line\n            if (key.downArrow) {\n                resetBlink();\n                const currentLineEnd = findLineEnd(value, cursor);\n                if (currentLineEnd >= value.length) {\n                    // On last line — insert a new line and move cursor there\n                    pushUndo('insert');\n                    setValue((v) => v + '\\n');\n                    setCursor(value.length + 1);\n                } else {\n                    setCursor((c) => {\n                        const {column} = getCursorLineAndColumn(value, c);\n                        const nextLineStart = currentLineEnd + 1;\n                        const nextLineEnd = findLineEnd(value, nextLineStart);\n                        const nextLineLength = nextLineEnd - nextLineStart;\n                        return nextLineStart + Math.min(column, nextLineLength);\n                    });\n                }\n                return;\n            }\n\n            // Left arrow\n            if (key.leftArrow) {\n                resetBlink();\n                setCursor((c) => Math.max(0, c - 1));\n                return;\n            }\n\n            // Right arrow\n            if (key.rightArrow) {\n                resetBlink();\n                setCursor((c) => Math.min(value.length, c + 1));\n                return;\n            }\n\n            // Opt+Left (meta+b) — word jump backward\n            if (key.meta && input === 'b') {\n                resetBlink();\n                setCursor((c) => findPrevWordBoundary(value, c));\n                return;\n            }\n\n            // Opt+Right (meta+f) — word jump forward\n            if (key.meta && input === 'f') {\n                resetBlink();\n                setCursor((c) => findNextWordBoundary(value, c));\n                return;\n            }\n\n            // Ctrl+A — start of current line\n            if (key.ctrl && input === 'a') {\n                resetBlink();\n                setCursor((c) => findLineStart(value, c));\n                return;\n            }\n\n            // Ctrl+E — end of current line\n            if (key.ctrl && input === 'e') {\n                resetBlink();\n                setCursor((c) => findLineEnd(value, c));\n                return;\n            }\n\n            // Ctrl+W — delete word before cursor\n            if (key.ctrl && input === 'w') {\n                resetBlink();\n                pushUndo('delete');\n                setCursor((c) => {\n                    const boundary = findPrevWordBoundary(value, c);\n                    setValue((v) => v.slice(0, boundary) + v.slice(c));\n                    return boundary;\n                });\n                return;\n            }\n\n            // Ctrl+U — delete to start of current line\n            if (key.ctrl && input === 'u') {\n                resetBlink();\n                pushUndo('delete');\n                setCursor((c) => {\n                    const lineStart = findLineStart(value, c);\n                    setValue((v) => v.slice(0, lineStart) + v.slice(c));\n                    return lineStart;\n                });\n                return;\n            }\n\n            // Ctrl+K — delete to end of current line\n            if (key.ctrl && input === 'k') {\n                resetBlink();\n                pushUndo('delete');\n                setCursor((c) => {\n                    const lineEnd = findLineEnd(value, c);\n                    setValue((v) => v.slice(0, c) + v.slice(lineEnd));\n                    return c;\n                });\n                return;\n            }\n\n            // Backspace (with Opt+Backspace for word deletion)\n            if (key.backspace || key.delete) {\n                if (key.meta) {\n                    // Opt+Delete — delete word before cursor\n                    resetBlink();\n                    pushUndo('delete');\n                    const boundary = findPrevWordBoundary(value, cursor);\n                    setValue((v) => v.slice(0, boundary) + v.slice(cursor));\n                    setCursor(boundary);\n                    return;\n                }\n                if (cursor > 0) {\n                    resetBlink();\n                    pushUndo('delete');\n                    setValue((v) => v.slice(0, cursor - 1) + v.slice(cursor));\n                    setCursor((c) => c - 1);\n                }\n                return;\n            }\n\n            // Ctrl+Z — undo\n            if (key.ctrl && input === 'z') {\n                resetBlink();\n                const entry = undoStack.current.pop();\n                if (entry) {\n                    setValue(entry.value);\n                    setCursor(entry.cursor);\n                }\n                lastMutationTime.current = 0;\n                lastMutationType.current = null;\n                return;\n            }\n\n            // Ignore other control/meta/escape/tab keys\n            if (key.ctrl || key.escape || key.tab) {\n                return;\n            }\n\n            // Regular character input\n            if (input && input.length > 0) {\n                resetBlink();\n                pushUndo('insert');\n                setValue((v) => v.slice(0, cursor) + input + v.slice(cursor));\n                setCursor((c) => c + input.length);\n            }\n        },\n        {isActive},\n    );\n\n    const renderLine = (\n        content: ReactNode,\n        key: string | number,\n        lineNumber: number,\n        totalLines: number,\n    ): ReactNode => {\n        const prefix =\n            typeof linePrefix === 'function'\n                ? linePrefix(lineNumber, totalLines)\n                : linePrefix;\n\n        return prefix ? (\n            <Box key={key}>\n                {prefix}\n                {content}\n            </Box>\n        ) : (\n            <Box key={key}>{content}</Box>\n        );\n    };\n\n    // Render placeholder when empty and not focused\n    if (value.length === 0 && !isActive && placeholder) {\n        return (\n            <Box flexDirection=\"column\">\n                {renderLine(<Text dimColor>{placeholder}</Text>, 0, 0, 2)}\n                {renderLine(<Text> </Text>, 1, 1, 2)}\n            </Box>\n        );\n    }\n\n    // Render placeholder with cursor when empty and focused\n    if (value.length === 0 && isActive) {\n        return (\n            <Box flexDirection=\"column\">\n                {renderLine(\n                    <Text>\n                        {cursorVisible ? '\\x1b[7m \\x1b[27m' : ' '}\n                        {placeholder ? (\n                            <Text dimColor>{placeholder}</Text>\n                        ) : null}\n                    </Text>,\n                    0,\n                    0,\n                    2,\n                )}\n                {renderLine(<Text> </Text>, 1, 1, 2)}\n            </Box>\n        );\n    }\n\n    // Multi-line rendering (minimum 2 visible lines)\n    const lines = value.split('\\n');\n    const totalLines = Math.max(lines.length, 2);\n    const hasContent = value.replace(/\\n/g, '').length > 0;\n    const {line: cursorLine, column: cursorColumn} = getCursorLineAndColumn(\n        value,\n        cursor,\n    );\n\n    const renderedLines = lines.map((lineText, lineIdx) => {\n        const isCursorLine = lineIdx === cursorLine;\n\n        if (!isCursorLine || !isActive) {\n            return renderLine(\n                <Text>\n                    {lineText || ' '}\n                    {lineIdx === 0 && !hasContent && placeholder ? (\n                        <Text dimColor>{placeholder}</Text>\n                    ) : null}\n                </Text>,\n                lineIdx,\n                lineIdx,\n                totalLines,\n            );\n        }\n\n        const before = lineText.slice(0, cursorColumn);\n        const atCursor = lineText[cursorColumn] ?? ' ';\n        const after = lineText.slice(cursorColumn + 1);\n\n        return renderLine(\n            <Text>\n                {before}\n                {cursorVisible\n                    ? `\\x1b[7m${atCursor}\\x1b[27m`\n                    : atCursor === ' ' && cursorColumn >= lineText.length\n                      ? ' '\n                      : atCursor}\n                {after}\n                {lineIdx === 0 && !hasContent && placeholder ? (\n                    <Text dimColor>{placeholder}</Text>\n                ) : null}\n            </Text>,\n            lineIdx,\n            lineIdx,\n            totalLines,\n        );\n    });\n\n    // Pad to minimum 2 lines so the input visually signals multi-line\n    while (renderedLines.length < 2) {\n        const padIdx = renderedLines.length;\n        renderedLines.push(\n            renderLine(<Text> </Text>, `pad-${padIdx}`, padIdx, totalLines),\n        );\n    }\n\n    return <Box flexDirection=\"column\">{renderedLines}</Box>;\n};\n"]}

package/dist/ui/components/UserExplanation.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from 'react';
+import type { TStore } from '../../store.mjs';
+type TUserExplanationProps = {
+    readonly store: TStore;
+};
+export declare const UserExplanation: (({ store }: TUserExplanationProps) => ReactNode) & {
+    displayName: string;
+};
+export {};
+//# sourceMappingURL=UserExplanation.d.ts.map

package/dist/ui/components/UserExplanation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserExplanation.d.ts","sourceRoot":"./src/","sources":["ui/components/UserExplanation.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,OAAO,CAAC;AAGrC,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,iBAAiB,CAAC;AAG5C,KAAK,qBAAqB,GAAG;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CAC1B,CAAC;AASF,eAAO,MAAM,eAAe,eACd,qBAAqB,KAAG,SAAS;;CAuE9C,CAAC"}

package/dist/ui/components/UserExplanation.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { observer } from 'mobx-react-lite';
+import { runInAction } from 'mobx';
+import { TextInput } from './TextInput.js';
+const TRUNCATE_LENGTH = 80;
+const truncate = (text) => text.length > TRUNCATE_LENGTH
+    ? `${text.slice(0, TRUNCATE_LENGTH)}...`
+    : text;
+export const UserExplanation = observer(({ store }) => {
+    const step = store.steps.userExplanation;
+    if (step.state === 'idle') {
+        return null;
+    }
+    if (step.state === 'done') {
+        return (_jsx(Box, { flexDirection: "column", children: _jsxs(Box, { children: [_jsx(Text, { color: "green", children: "\u25CF" }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "EXPLANATION: " }), _jsx(Text, { dimColor: true, children: truncate(step.value ?? '') })] }) }));
+    }
+    const handleSubmit = (value) => {
+        const trimmed = value.trim();
+        if (trimmed.length === 0) {
+            return;
+        }
+        runInAction(() => {
+            store.steps.userExplanation.value = trimmed;
+            store.steps.userExplanation.state = 'done';
+        });
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: "\u25CF" }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "EXPLANATION: " }), _jsx(Text, { children: "Describe this database" })] }), _jsxs(Box, { paddingLeft: 2, flexDirection: "column", children: [_jsx(Box, { width: 96, flexDirection: 'column', paddingTop: 1, children: _jsx(Text, { dimColor: true, children: "Mention what kind of DB it is, which app it's for, what the business is, if it's standalone or part of a larger ecosystem, and what the app does (Ctrl+J for new line)" }) }), _jsx(Text, { children: " " }), _jsx(TextInput, { isActive: step.state === 'prompting', onSubmit: handleSubmit, placeholder: "e.g. a multi-vendor ecommerce platform part of a larger superapp", linePrefix: (lineNumber, totalLines) => {
+                            const width = String(totalLines).length;
+                            const num = String(lineNumber + 1).padStart(width, ' ');
+                            return (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: num }), _jsx(Text, { color: "gray", children: " \u2503 " })] }));
+                        } })] })] }));
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/validatePaths.d.mts

@@ -4,6 +4,7 @@ export type TPathValidationError = {
     path: string;
     error: string;
 };
+export declare const normalizePath: (path: string) => string;
 export declare const validatePathOptions: <T extends Partial<Record<TPathOptionKey, string>>>(options: T) => {
     errors: TPathValidationError[];
     expandedPaths: Partial<Record<TPathOptionKey, string>>;

package/dist/validatePaths.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"validatePaths.d.mts","sourceRoot":"./src/","sources":["validatePaths.mts"],"names":[],"mappings":"AAQA,KAAK,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,aAAa,GAAG,QAAQ,CAAC;AAEtE,MAAM,MAAM,oBAAoB,GAAG;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACjB,CAAC;AAwBF,eAAO,MAAM,mBAAmB,GAC5B,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC,EAEjD,SAAS,CAAC,KACX;IACC,MAAM,EAAE,oBAAoB,EAAE,CAAC;IAC/B,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC;CA0C1D,CAAC"}
+{"version":3,"file":"validatePaths.d.mts","sourceRoot":"./src/","sources":["validatePaths.mts"],"names":[],"mappings":"AAQA,KAAK,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,aAAa,GAAG,QAAQ,CAAC;AAEtE,MAAM,MAAM,oBAAoB,GAAG;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACjB,CAAC;AAOF,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,KAAG,MACf,CAAC;AAiB/B,eAAO,MAAM,mBAAmB,GAC5B,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC,EAEjD,SAAS,CAAC,KACX;IACC,MAAM,EAAE,oBAAoB,EAAE,CAAC;IAC/B,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC;CA0C1D,CAAC"}

package/dist/validatePaths.mjs

@@ -4,7 +4,7 @@ import { resolve } from 'node:path';
 const expandTilde = (path) => path.startsWith('~/') || path === '~'
     ? path.replace(/^~/, homedir())
     : path;
-const normalizePath = (path) => resolve(expandTilde(path));
+export const normalizePath = (path) => resolve(expandTilde(path));
 const validatePathExists = (path) => {
     const expandedPath = normalizePath(path);
     return existsSync(expandedPath)
@@ -51,4 +51,4 @@ export const validatePathOptions = (options) => {
     }), {});
     return { errors, expandedPaths };
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbctx",
-  "version": "1.4.5",
+  "version": "1.5.0",
   "description": "AI-enriched database context for humans and coding agents",
   "type": "module",
   "main": "dist/index.mjs",

package/dist/schemas/index.d.mts

@@ -1,107 +0,0 @@
-import { z } from 'zod';
-export declare const database: z.ZodObject<{
-    type: z.ZodEnum<{
-        postgresql: "postgresql";
-    }>;
-    version: z.ZodObject<{
-        version_string: z.ZodString;
-        version_number: z.ZodNumber;
-    }, z.core.$strip>;
-    identifier: z.ZodObject<{
-        system_identifier: z.ZodString;
-        database_oid: z.ZodNumber;
-    }, z.core.$strip>;
-    name: z.ZodString;
-    comment: z.ZodNullable<z.ZodString>;
-    summary: z.ZodOptional<z.ZodString>;
-    details: z.ZodOptional<z.ZodString>;
-    relations: z.ZodRecord<z.ZodString, z.ZodObject<{
-        name: z.ZodString;
-        comment: z.ZodNullable<z.ZodString>;
-        kind: z.ZodEnum<{
-            partitioned_table: "partitioned_table";
-            table: "table";
-            view: "view";
-            materialized_view: "materialized_view";
-        }>;
-        summary: z.ZodOptional<z.ZodString>;
-        details: z.ZodOptional<z.ZodString>;
-        attributes: z.ZodRecord<z.ZodString, z.ZodIntersection<z.ZodObject<{
-            name: z.ZodString;
-            data_type: z.ZodString;
-            is_nullable: z.ZodBoolean;
-            comment: z.ZodNullable<z.ZodString>;
-            estimated_distinct: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"regular">;
-            has_default: z.ZodLiteral<false>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<"regular">;
-            has_default: z.ZodLiteral<true>;
-            default_expression: z.ZodString;
-        }, z.core.$strip>], "has_default">, z.ZodObject<{
-            kind: z.ZodLiteral<"generated">;
-            generated_storage: z.ZodEnum<{
-                stored: "stored";
-                virtual: "virtual";
-            }>;
-            generated_expression: z.ZodString;
-        }, z.core.$strip>], "kind">>>;
-        references: z.ZodRecord<z.ZodString, z.ZodObject<{
-            constraint_name: z.ZodString;
-            attributes: z.ZodArray<z.ZodString>;
-            referenced_relation: z.ZodString;
-            referenced_attributes: z.ZodArray<z.ZodString>;
-            on_update: z.ZodEnum<{
-                "NO ACTION": "NO ACTION";
-                RESTRICT: "RESTRICT";
-                CASCADE: "CASCADE";
-                "SET NULL": "SET NULL";
-                "SET DEFAULT": "SET DEFAULT";
-            }>;
-            on_delete: z.ZodEnum<{
-                "NO ACTION": "NO ACTION";
-                RESTRICT: "RESTRICT";
-                CASCADE: "CASCADE";
-                "SET NULL": "SET NULL";
-                "SET DEFAULT": "SET DEFAULT";
-            }>;
-            comment: z.ZodNullable<z.ZodString>;
-        }, z.core.$strip>>;
-        indexes: z.ZodRecord<z.ZodString, z.ZodIntersection<z.ZodIntersection<z.ZodObject<{
-            index_name: z.ZodString;
-            relation_name: z.ZodString;
-            attributes: z.ZodArray<z.ZodString>;
-            definition: z.ZodString;
-            comment: z.ZodNullable<z.ZodString>;
-        }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-            index_kind: z.ZodLiteral<"primary">;
-        }, z.core.$strip>, z.ZodObject<{
-            index_kind: z.ZodLiteral<"unique">;
-        }, z.core.$strip>, z.ZodObject<{
-            index_kind: z.ZodLiteral<"exclusion">;
-            exclusion_operators: z.ZodArray<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            index_kind: z.ZodLiteral<"plain">;
-        }, z.core.$strip>], "index_kind">>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-            is_partial: z.ZodLiteral<false>;
-        }, z.core.$strip>, z.ZodObject<{
-            is_partial: z.ZodLiteral<true>;
-            partial_predicate: z.ZodString;
-        }, z.core.$strip>], "is_partial">>>;
-        fileStats: z.ZodOptional<z.ZodObject<{
-            file_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            modification_time: z.ZodOptional<z.ZodDate>;
-            size_bytes: z.ZodOptional<z.ZodNumber>;
-            is_partitioned: z.ZodOptional<z.ZodBoolean>;
-            partition_count: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-            estimated_row_count: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    enums: z.ZodRecord<z.ZodString, z.ZodObject<{
-        values: z.ZodArray<z.ZodString>;
-        comment: z.ZodNullable<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type TDatabase = z.infer<typeof database>;
-//# sourceMappingURL=index.d.mts.map

package/dist/schemas/index.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"./src/","sources":["schemas/index.mts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAgHtB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgBnB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC"}