@callakrsos/my-ollama-cli 1.0.0

package/skills/index.js

@@ -0,0 +1,50 @@
+import fs from "fs/promises";
+import path from "path";
+
+const BASE_DIR = process.cwd();
+export const SKILLS_PATH = path.join(BASE_DIR, 'skills.json');
+
+export const DEFAULT_SKILLS = {
+    "commit": {
+        "description": "Git 커밋 메시지를 자동으로 작성합니다",
+        "prompt": "execute_shell_command 도구로 'git diff --cached'와 'git status'를 실행하고, 변경 사항을 분석하여 Conventional Commits 형식(feat/fix/docs/refactor/chore 등)으로 한국어 커밋 메시지를 작성해주세요."
+    },
+    "review": {
+        "description": "코드 리뷰를 수행합니다",
+        "prompt": "주어진 파일 또는 최근 변경 사항을 분석하여 코드 리뷰를 수행해주세요. 버그 가능성, 성능 이슈, 보안 문제, 코드 품질, 개선 제안을 항목별로 정리해주세요."
+    },
+    "explain": {
+        "description": "코드나 파일을 쉽게 설명합니다",
+        "prompt": "주어진 코드 또는 파일을 읽고, 전체 흐름과 핵심 로직을 개발자가 이해하기 쉽게 단계별로 설명해주세요."
+    },
+    "test": {
+        "description": "테스트 코드를 작성합니다",
+        "prompt": "주어진 코드를 분석하고, 핵심 기능에 대한 단위 테스트 코드를 작성해주세요. 경계 조건과 예외 케이스도 포함해주세요."
+    },
+    "refactor": {
+        "description": "코드를 리팩토링합니다",
+        "prompt": "주어진 코드를 더 읽기 쉽고 유지보수하기 좋게 리팩토링해주세요. 중복 제거, 명확한 변수명, 함수 분리 등을 고려해주세요."
+    },
+    "doc": {
+        "description": "문서(JSDoc/docstring/README)를 작성합니다",
+        "prompt": "주어진 코드를 분석하고, 함수/클래스에 JSDoc 또는 docstring 주석을 추가하고 필요하면 README 섹션도 작성해주세요."
+    },
+    "analyze": {
+        "description": "데이터나 로그를 Python으로 분석합니다",
+        "prompt": "주어진 데이터 또는 파일을 execute_python_code 도구를 사용해 Python으로 분석하고, 결과를 요약해주세요. 필요시 통계나 시각화 코드도 작성해주세요."
+    },
+    "security": {
+        "description": "보안 취약점을 검토합니다",
+        "prompt": "주어진 코드를 OWASP Top 10 기준으로 보안 취약점을 검토하고, 발견된 문제와 개선 방법을 구체적으로 알려주세요."
+    },
+};
+
+export async function loadSkills() {
+    try {
+        const raw = await fs.readFile(SKILLS_PATH, 'utf-8');
+        const custom = JSON.parse(raw);
+        return { ...DEFAULT_SKILLS, ...custom };
+    } catch (e) {
+        return DEFAULT_SKILLS;
+    }
+}

package/skills.example.json

@@ -0,0 +1,15 @@
+{
+  "_comment": "이 파일을 skills.json으로 복사하면 커스텀 스킬을 추가하거나 기본 스킬을 덮어쓸 수 있습니다.",
+  "my-skill": {
+    "description": "나만의 커스텀 스킬 예시",
+    "prompt": "여기에 AI에게 전달할 프롬프트를 작성하세요."
+  },
+  "standup": {
+    "description": "오늘 작업 요약(스탠드업 미팅용)을 작성합니다",
+    "prompt": "execute_shell_command 도구로 'git log --since=yesterday --oneline --author=$(git config user.email)' 를 실행하고, 어제부터 오늘 사이의 커밋 내역을 바탕으로 스탠드업 미팅용 업무 보고를 3줄로 요약해주세요."
+  },
+  "deps": {
+    "description": "package.json 의존성 취약점 및 업데이트 분석",
+    "prompt": "execute_shell_command 도구로 'npm outdated' 와 'npm audit --json' 을 실행하고 결과를 분석하여 업데이트가 필요한 패키지와 보안 취약점을 정리해주세요."
+  }
+}

package/tools/fileTools.js

@@ -0,0 +1,65 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+import fs from "fs/promises";
+import { readFileWithBOM } from "../FilesUtils.js";
+import { getSafePath, truncateToolContent } from "./utils.js";
+
+export const readFileTool = new DynamicStructuredTool({
+    name: "read_file",
+    description: "파일의 내용을 읽어옵니다. 코드를 분석하거나 내용을 확인할 때 사용하세요.",
+    schema: z.object({
+        filePath: z.string().describe("읽을 파일의 경로 (예: ./src/index.js)"),
+    }),
+    func: async ({ filePath }) => {
+        console.log(`read_file tool 호출 ${filePath}`);
+        try {
+            const safePath = getSafePath(filePath);
+            const content = await readFileWithBOM(safePath);
+            const full = `[파일 내용 - ${filePath}]:\n${content}`;
+            return truncateToolContent(full, '파일');
+        } catch (error) {
+            return `파일 읽기 실패: ${error.message}`;
+        }
+    },
+});
+
+export const writeFileTool = new DynamicStructuredTool({
+    name: "write_file",
+    description: "파일을 생성하거나 내용을 덮어씁니다. 코드를 작성하거나 수정할 때 사용하세요.",
+    schema: z.object({
+        filePath: z.string().describe("저장할 파일 경로"),
+        content: z.string().describe("저장할 파일의 전체 내용"),
+    }),
+    func: async ({ filePath, content }) => {
+        console.log(`write_file tool 호출 ${filePath}`);
+        try {
+            const safePath = getSafePath(filePath);
+            await fs.writeFile(safePath, content, "utf-8");
+            return `성공: 파일이 저장되었습니다. (${filePath})`;
+        } catch (error) {
+            return `파일 쓰기 실패: ${error.message}`;
+        }
+    },
+});
+
+export const readPdfTool = new DynamicStructuredTool({
+    name: "read_pdf",
+    description: "PDF 파일의 텍스트 내용을 읽어옵니다. 문서 내용을 분석하거나 정보를 추출할 때 사용하세요.",
+    schema: z.object({
+        filePath: z.string().describe("읽을 PDF 파일의 경로 (예: ./docs/manual.pdf)"),
+    }),
+    func: async ({ filePath }) => {
+        try {
+            console.log("read_pdf tool 호출");
+            const safePath = getSafePath(filePath);
+            const dataBuffer = await fs.readFile(safePath);
+            // pdf-parse 패키지 필요: npm install pdf-parse
+            const pdfParse = (await import('pdf-parse')).default;
+            const result = await pdfParse(dataBuffer);
+            const full = `[PDF 내용 - ${filePath}]:\n${result.text}`;
+            return truncateToolContent(full, 'PDF');
+        } catch (error) {
+            return `PDF 읽기 실패: ${error.message}`;
+        }
+    },
+});

package/tools/index.js

@@ -0,0 +1,13 @@
+export { readFileTool, writeFileTool, readPdfTool } from './fileTools.js';
+export { executeShellTool, executePythonTool } from './shellTools.js';
+
+import { readFileTool, writeFileTool, readPdfTool } from './fileTools.js';
+import { executeShellTool, executePythonTool } from './shellTools.js';
+
+export const tools = [
+    readFileTool,
+    writeFileTool,
+    executeShellTool,
+    executePythonTool,
+    readPdfTool,
+];

package/tools/shellTools.js

@@ -0,0 +1,83 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+import { spawn } from "child_process";
+import path from "path";
+import os from "os";
+import fs from "fs/promises";
+import chalk from "chalk";
+
+export const executeShellTool = new DynamicStructuredTool({
+    name: "execute_shell_command",
+    description: "터미널(셸) 명령어를 실행하고 결과를 반환합니다. ipconfig, ls, pwd, date 같은 시스템 확인용 명령에 사용하세요.",
+    schema: z.object({
+        command: z.string().describe("실행할 셸 명령어 (예: ipconfig)"),
+    }),
+    func: async ({ command }) => {
+        const blocklist = ["rm", "del", "sudo", "su", "shutdown", "reboot"];
+        const commandBase = command.split(" ")[0];
+        if (blocklist.includes(commandBase)) {
+            return `에러: 보안상의 이유로 '${commandBase}' 명령어는 실행할 수 없습니다.`;
+        }
+        console.log(chalk.gray(`[툴 실행] 셸 명령어 실행: ${command}`));
+        return new Promise((resolve) => {
+            const child = spawn(command, { shell: 'powershell.exe' });
+            let stdout = '';
+            let stderr = '';
+            child.stdout.on('data', (data) => { stdout += data.toString('utf-8'); });
+            child.stderr.on('data', (data) => { stderr += data.toString('utf-8'); });
+            child.on('close', (code) => {
+                let output = `종료 코드: ${code}\n`;
+                if (stdout.trim()) output += `STDOUT:\n${stdout.trim()}\n`;
+                if (stderr.trim()) output += `STDERR:\n${stderr.trim()}\n`;
+                if (code === 0) {
+                    resolve(`명령어 실행 성공:\n${output}`);
+                } else {
+                    resolve(`명령어 실행 중 에러 발생:\n${output}`);
+                }
+            });
+            child.on('error', (err) => resolve(`명령어 실행 실패: ${err.message}`));
+        });
+    },
+});
+
+export const executePythonTool = new DynamicStructuredTool({
+    name: "execute_python_code",
+    description: "Python 코드를 작성하고 실행합니다. 데이터 분석, 수치 계산, 파일 처리, 자동화 스크립트 작성 등에 사용하세요.",
+    schema: z.object({
+        code: z.string().describe("실행할 Python 코드 (전체 내용)"),
+        description: z.string().optional().describe("코드 설명 (선택 사항)"),
+    }),
+    func: async ({ code, description }) => {
+        const tmpFile = path.join(os.tmpdir(), `kyj_cli_py_${Date.now()}.py`);
+        try {
+            if (description) console.log(chalk.gray(`[툴 실행] Python 코드 실행: ${description}`));
+            else console.log(chalk.gray(`[툴 실행] Python 코드 실행 중...`));
+            await fs.writeFile(tmpFile, code, 'utf-8');
+            return new Promise((resolve) => {
+                const child = spawn('python', [tmpFile], { stdio: 'pipe' });
+                let stdout = '';
+                let stderr = '';
+                child.stdout.on('data', (data) => { stdout += data.toString('utf-8'); });
+                child.stderr.on('data', (data) => { stderr += data.toString('utf-8'); });
+                child.on('close', async (exitCode) => {
+                    try { await fs.unlink(tmpFile); } catch (_) {}
+                    let output = '';
+                    if (stdout.trim()) output += `STDOUT:\n${stdout.trim()}\n`;
+                    if (stderr.trim()) output += `STDERR:\n${stderr.trim()}\n`;
+                    if (exitCode === 0) {
+                        resolve(`Python 코드 실행 성공 (종료 코드: ${exitCode}):\n${output || '(출력 없음)'}`);
+                    } else {
+                        resolve(`Python 코드 실행 실패 (종료 코드: ${exitCode}):\n${output}`);
+                    }
+                });
+                child.on('error', async (err) => {
+                    try { await fs.unlink(tmpFile); } catch (_) {}
+                    resolve(`Python 실행 실패: ${err.message}\n(Python이 설치되어 있는지 확인하세요. 명령어: python --version)`);
+                });
+            });
+        } catch (error) {
+            try { await fs.unlink(tmpFile); } catch (_) {}
+            return `Python 코드 실행 실패: ${error.message}`;
+        }
+    },
+});

package/tools/utils.js

@@ -0,0 +1,19 @@
+import path from 'path';
+
+export const BASE_DIR = process.cwd();
+
+export const TOOL_CONTENT_MAX_CHARS = 1200000;
+
+export function getSafePath(targetPath) {
+    const resolvedPath = path.resolve(BASE_DIR, targetPath);
+    if (!resolvedPath.startsWith(BASE_DIR)) {
+        throw new Error("보안 경고: 현재 작업 디렉터리를 벗어난 파일에는 접근할 수 없습니다.");
+    }
+    return resolvedPath;
+}
+
+export function truncateToolContent(text, label = '파일') {
+    if (typeof text !== 'string' || text.length <= TOOL_CONTENT_MAX_CHARS) return text;
+    return text.slice(0, TOOL_CONTENT_MAX_CHARS) +
+        `\n\n... (${label} 내용이 ${text.length}자라 ${TOOL_CONTENT_MAX_CHARS}자까지만 전달했습니다. 필요한 부분을 지정해 다시 요청하세요.)`;
+}

package/ui/fileSelector.js

@@ -0,0 +1,44 @@
+import { glob } from 'glob';
+import { checkbox } from '@inquirer/prompts';
+import search from "../search/search/dist/index.js";
+import chalk from 'chalk';
+
+const IGNORE = ['node_modules/**', '.git/**', '*.env', '**/node_modules/**', '**/.git/**', '.m2/**', '.idea/**'];
+
+export async function selectFile(initialInput = '') {
+    const allFiles = await glob('**/*', { ignore: IGNORE, nodir: true });
+    const initialFiles = initialInput
+        ? allFiles.filter(f => f.toLowerCase().includes(initialInput.toLowerCase()))
+        : allFiles;
+
+    return await search({
+        message: '첨부할 파일을 선택하세요:',
+        source: async (input) => {
+            if (input === undefined) return initialFiles;
+            if (!input) return allFiles;
+            return allFiles.filter(f => f.toLowerCase().includes(input.toLowerCase()));
+        },
+    });
+}
+
+export async function selectMultipleFiles(initialInput = '') {
+    const allFiles = await glob('**/*', { ignore: IGNORE, nodir: true });
+    let filtered = initialInput
+        ? allFiles.filter(f => f.toLowerCase().includes(initialInput.toLowerCase()))
+        : allFiles;
+
+    if (filtered.length === 0) {
+        console.log(chalk.yellow('검색 결과가 없습니다.'));
+        return [];
+    }
+    if (filtered.length > 80) {
+        console.log(chalk.gray(`  ${filtered.length}개 파일 중 80개만 표시됩니다. '@@검색어'로 범위를 좁히세요.`));
+        filtered = filtered.slice(0, 80);
+    }
+
+    return await checkbox({
+        message: `첨부할 파일을 선택하세요 ${chalk.gray('(Space: 선택/해제, Enter: 확인, a: 전체선택)')}:`,
+        choices: filtered.map(f => ({ name: f, value: f })),
+        pageSize: 15,
+    });
+}

package/ui/prompt.js

@@ -0,0 +1,347 @@
+import { glob } from 'glob';
+import chalk from 'chalk';
+
+const IGNORE = ['node_modules/**', '.git/**', '*.env', '**/node_modules/**', '**/.git/**', '.m2/**', '.idea/**'];
+
+/** 터미널 스피너 (외부 라이브러리 없이 구현) */
+export function createSpinner(text) {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let i = 0;
+    let currentText = text;
+    const interval = setInterval(() => {
+        process.stdout.write(`\r${chalk.cyan(frames[i++ % frames.length])} ${currentText}   `);
+    }, 80);
+    return {
+        update: (newText) => { currentText = newText; },
+        stop: () => {
+            clearInterval(interval);
+            process.stdout.write('\r' + ' '.repeat(currentText.length + 5) + '\r');
+        },
+    };
+}
+
+/**
+ * Claude / Gemini 스타일 멀티라인 입력 컴포넌트 (인라인 @ 파일 피커 포함)
+ *
+ * Enter    : 줄바꿈  (피커 열려 있으면 파일 선택)
+ * Ctrl+S   : 전송
+ * Ctrl+D   : 전송
+ * ↑↓       : 히스토리 (피커 열려 있으면 피커 탐색)
+ * ← →      : 커서 이동
+ * Backspace: 문자/줄 삭제
+ * Esc      : 피커 닫기
+ * @        : 입력 커서 위치에서 단어가 @ 로 시작하면 파일 피커 팝업
+ * @@       : 피커 미적용 (기존 멀티파일 명령어)
+ */
+export function cliPrompt(history = []) {
+    const P0 = '  ❯ ';
+    const PN = '    ';
+    const pre = (r) => r === 0 ? P0 : PN;
+    const PICKER_SIZE = 10;
+
+    return new Promise(async (resolve, reject) => {
+        let allPickerFiles = [];
+        try {
+            allPickerFiles = await glob('**/*', { ignore: IGNORE, nodir: true });
+        } catch (_) {}
+
+        let lines = [''];
+        let row = 0, col = 0;
+        let histIdx = -1, draft = '';
+        let screenLines = 1;
+
+        let pickerActive = false;
+        let pickerFiles = [];
+        let pickerIdx = 0;
+        let pickerOffset = 0;
+        let pickerScreenLines = 0;
+
+        const W = process.stdout.columns || 100;
+        process.stdout.write('\n' + chalk.gray('─'.repeat(W)) + '\n');
+        process.stdout.write(
+            chalk.green.bold('  You') +
+            chalk.gray('  (Enter: 줄바꿈  Ctrl+S: 전송  ↑↓: 히스토리  @파일명: 파일첨부)') + '\n'
+        );
+        process.stdout.write(P0);
+
+        function strWidth(str) {
+            let w = 0;
+            for (const ch of str) {
+                const code = ch.codePointAt(0);
+                if (code >= 0x1100 && (
+                    code <= 0x115F ||
+                    code === 0x2329 || code === 0x232A ||
+                    (code >= 0x2E80 && code <= 0x303E) ||
+                    (code >= 0x3040 && code <= 0x33BF) ||
+                    (code >= 0xAC00 && code <= 0xD7AF) ||
+                    (code >= 0xF900 && code <= 0xFAFF) ||
+                    (code >= 0xFF01 && code <= 0xFF60) ||
+                    (code >= 0xFFE0 && code <= 0xFFE6)
+                )) {
+                    w += 2;
+                } else {
+                    w += 1;
+                }
+            }
+            return w;
+        }
+        const colW = () => strWidth(lines[row].slice(0, col));
+
+        function getAtWord() {
+            const line = lines[row];
+            let start = col;
+            while (start > 0 && line[start - 1] !== ' ' && line[start - 1] !== '\n') start--;
+            const word = line.slice(start, col);
+            if (word.startsWith('@') && !word.startsWith('@@')) return { word, start };
+            return null;
+        }
+
+        function filterFiles(query) {
+            if (!query) return allPickerFiles.slice(0, 300);
+            const q = query.toLowerCase();
+            return allPickerFiles.filter(f => f.toLowerCase().includes(q)).slice(0, 300);
+        }
+
+        function syncPicker() {
+            const atWord = getAtWord();
+            if (atWord) {
+                pickerFiles = filterFiles(atWord.word.slice(1));
+                if (pickerIdx >= pickerFiles.length) pickerIdx = Math.max(0, pickerFiles.length - 1);
+                pickerActive = true;
+            } else {
+                pickerActive = false;
+                pickerFiles = [];
+                pickerIdx = 0;
+                pickerOffset = 0;
+            }
+        }
+
+        const fullRedraw = (prevInputLines = screenLines, prevPickerLines = pickerScreenLines) => {
+            const newInputLines = lines.length;
+            const newPickerLines = (pickerActive && pickerFiles.length > 0)
+                ? Math.min(PICKER_SIZE, pickerFiles.length) + 1
+                : 0;
+
+            if (row > 0) process.stdout.moveCursor(0, -row);
+            process.stdout.cursorTo(0);
+
+            const maxTotal = Math.max(newInputLines + newPickerLines, prevInputLines + prevPickerLines);
+
+            for (let i = 0; i < maxTotal; i++) {
+                process.stdout.clearLine(0);
+                if (i < newInputLines) {
+                    process.stdout.write(pre(i) + lines[i]);
+                } else if (i < newInputLines + newPickerLines) {
+                    const pi = i - newInputLines;
+                    if (pi === 0) {
+                        const total = pickerFiles.length;
+                        const more = total > PICKER_SIZE ? chalk.gray(` +${total - PICKER_SIZE}개`) : '';
+                        process.stdout.write(
+                            chalk.bgGray.white(' 파일 ') +
+                            chalk.gray(` ${total}개${more}  `) +
+                            chalk.gray('↑↓이동') + chalk.gray('  ') +
+                            chalk.cyan('Enter') + chalk.gray(':선택  ') +
+                            chalk.yellow('Esc') + chalk.gray(':닫기')
+                        );
+                    } else {
+                        const fileIdx = pickerOffset + pi - 1;
+                        const file = pickerFiles[fileIdx];
+                        if (file !== undefined) {
+                            if (fileIdx === pickerIdx) {
+                                process.stdout.write(chalk.cyan('  ❯ ') + chalk.bold(file));
+                            } else {
+                                process.stdout.write(chalk.gray('    ') + file);
+                            }
+                        }
+                    }
+                }
+                if (i < maxTotal - 1) process.stdout.write('\n');
+            }
+
+            const moveUp = (maxTotal - 1) - row;
+            if (moveUp > 0) process.stdout.moveCursor(0, -moveUp);
+            process.stdout.cursorTo(pre(row).length + colW());
+
+            screenLines = newInputLines;
+            pickerScreenLines = newPickerLines;
+        };
+
+        const end = () => {
+            process.stdin.setRawMode(false);
+            process.stdin.removeListener('data', onData);
+        };
+        const submit = () => {
+            if (pickerActive || pickerScreenLines > 0) {
+                pickerActive = false;
+                fullRedraw(screenLines, pickerScreenLines);
+            }
+            end();
+            process.stdout.write('\n');
+            resolve(lines.join('\n').trim());
+        };
+        const cancel = () => {
+            end();
+            process.stdout.write('\n');
+            reject({ name: 'ExitPromptError' });
+        };
+
+        const onData = (buf) => {
+            const s = buf.toString('utf8');
+
+            // Windows IME 조합 시퀀스: \b + 문자
+            if (s.length >= 2 && (s[0] === '\u0008' || s[0] === '\u007f')) {
+                const rest = s.slice(1);
+                if (rest.length >= 1 && rest.charCodeAt(0) >= 32 && !rest.startsWith('\u001b')) {
+                    if (col > 0) {
+                        lines[row] = lines[row].slice(0, col - 1) + rest + lines[row].slice(col);
+                        const prevPicker = pickerScreenLines;
+                        syncPicker();
+                        fullRedraw(screenLines, prevPicker);
+                    }
+                    return;
+                }
+            }
+
+            if (s === '\u0003') { cancel(); return; }
+            if (s === '\u0013' || s === '\u0004') { submit(); return; }
+
+            if (s === '\u001b' || s === '\u001b\u001b') {
+                if (pickerActive) {
+                    const prevPicker = pickerScreenLines;
+                    pickerActive = false; pickerFiles = []; pickerIdx = 0; pickerOffset = 0;
+                    fullRedraw(screenLines, prevPicker);
+                }
+                return;
+            }
+
+            if (s === '\r' || s === '\n') {
+                if (pickerActive && pickerFiles.length > 0) {
+                    const selected = pickerFiles[pickerIdx];
+                    const atWord = getAtWord();
+                    if (atWord && selected) {
+                        const replacement = '@' + selected + ' ';
+                        lines[row] = lines[row].slice(0, atWord.start) + replacement + lines[row].slice(col);
+                        col = atWord.start + replacement.length;
+                    }
+                    const prevPicker = pickerScreenLines;
+                    pickerActive = false; pickerFiles = []; pickerIdx = 0; pickerOffset = 0;
+                    fullRedraw(screenLines, prevPicker);
+                    return;
+                }
+                if (lines.length === 1 && lines[0].trim() === '') return;
+                const after = lines[row].slice(col);
+                lines[row] = lines[row].slice(0, col);
+                lines.splice(row + 1, 0, after);
+                row++; col = 0;
+                const prevPicker = pickerScreenLines;
+                syncPicker();
+                fullRedraw(screenLines, prevPicker);
+                return;
+            }
+
+            if (s.startsWith('\u001b[')) {
+                switch (s) {
+                    case '\u001b[A': // ↑
+                        if (pickerActive) {
+                            if (pickerIdx > 0) { pickerIdx--; if (pickerIdx < pickerOffset) pickerOffset = pickerIdx; fullRedraw(screenLines, pickerScreenLines); }
+                        } else if (row > 0) {
+                            process.stdout.moveCursor(0, -1); row--;
+                            col = Math.min(col, lines[row].length);
+                            process.stdout.cursorTo(pre(row).length + colW());
+                        } else if (histIdx < history.length - 1) {
+                            if (histIdx === -1) draft = lines.join('\n');
+                            histIdx++;
+                            lines = history[history.length - 1 - histIdx].split('\n');
+                            row = 0; col = lines[0].length;
+                            fullRedraw();
+                        }
+                        break;
+                    case '\u001b[B': // ↓
+                        if (pickerActive) {
+                            if (pickerIdx < pickerFiles.length - 1) { pickerIdx++; if (pickerIdx >= pickerOffset + PICKER_SIZE) pickerOffset = pickerIdx - PICKER_SIZE + 1; fullRedraw(screenLines, pickerScreenLines); }
+                        } else if (row < lines.length - 1) {
+                            process.stdout.moveCursor(0, 1); row++;
+                            col = Math.min(col, lines[row].length);
+                            process.stdout.cursorTo(pre(row).length + colW());
+                        } else if (histIdx === 0) {
+                            histIdx = -1; const prev = screenLines;
+                            lines = draft ? draft.split('\n') : ['']; row = 0; col = lines[0].length;
+                            fullRedraw(prev);
+                        } else if (histIdx > 0) {
+                            histIdx--;
+                            lines = history[history.length - 1 - histIdx].split('\n');
+                            row = 0; col = lines[0].length; fullRedraw();
+                        }
+                        break;
+                    case '\u001b[D': // ←
+                        if (col > 0) { col--; process.stdout.cursorTo(pre(row).length + colW()); }
+                        else if (row > 0) { row--; col = lines[row].length; process.stdout.moveCursor(0, -1); process.stdout.cursorTo(pre(row).length + colW()); }
+                        break;
+                    case '\u001b[C': // →
+                        if (col < lines[row].length) { col++; process.stdout.cursorTo(pre(row).length + colW()); }
+                        else if (row < lines.length - 1) { row++; col = 0; process.stdout.moveCursor(0, 1); process.stdout.cursorTo(pre(row).length); }
+                        break;
+                    case '\u001b[H': case '\u001b[1~': // Home
+                        col = 0; process.stdout.cursorTo(pre(row).length); break;
+                    case '\u001b[F': case '\u001b[4~': // End
+                        col = lines[row].length; process.stdout.cursorTo(pre(row).length + strWidth(lines[row])); break;
+                    case '\u001b[3~': { // Delete
+                        const prevPicker = pickerScreenLines;
+                        if (col < lines[row].length) {
+                            lines[row] = lines[row].slice(0, col) + lines[row].slice(col + 1);
+                            syncPicker(); fullRedraw(screenLines, prevPicker);
+                        } else if (row < lines.length - 1) {
+                            lines[row] += lines[row + 1]; lines.splice(row + 1, 1);
+                            syncPicker(); fullRedraw(screenLines + 1, prevPicker);
+                        }
+                        break;
+                    }
+                }
+                return;
+            }
+
+            if (s === '\u007f' || s === '\b') {
+                const prevPicker = pickerScreenLines;
+                if (col > 0) {
+                    lines[row] = lines[row].slice(0, col - 1) + lines[row].slice(col);
+                    col--; syncPicker(); fullRedraw(screenLines, prevPicker);
+                } else if (row > 0) {
+                    const prevLen = lines[row - 1].length;
+                    lines[row - 1] += lines[row]; lines.splice(row, 1);
+                    row--; col = prevLen; syncPicker(); fullRedraw(screenLines + 1, prevPicker);
+                }
+                return;
+            }
+
+            if (s.length > 1) {
+                const text = s.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+                for (const ch of text) {
+                    if (ch === '\n') {
+                        const after = lines[row].slice(col);
+                        lines[row] = lines[row].slice(0, col);
+                        lines.splice(row + 1, 0, after);
+                        row++; col = 0;
+                    } else if (ch.charCodeAt(0) >= 32 || ch === '\t') {
+                        lines[row] = lines[row].slice(0, col) + ch + lines[row].slice(col);
+                        col++;
+                    }
+                }
+                const prevPicker = pickerScreenLines;
+                syncPicker(); fullRedraw(screenLines, prevPicker);
+                return;
+            }
+
+            if (s.charCodeAt(0) >= 32) {
+                lines[row] = lines[row].slice(0, col) + s + lines[row].slice(col);
+                col++;
+                const prevPicker = pickerScreenLines;
+                syncPicker(); fullRedraw(screenLines, prevPicker);
+            }
+        };
+
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', onData);
+    });
+}