berry-agent 0.1.0-alpha.1

package/dist/channels/tui/editor/editor.js

@@ -0,0 +1,275 @@
+import { EditorModel } from './editor-model.js';
+import { EditorView } from './editor-view.js';
+/* ---------------- 键位表（pi 平移——见类注差异注记） ---------------- */
+const SUBMIT = [{ key: 'enter' }];
+const NEW_LINE = [
+    { key: 'enter', shift: true },
+    { key: 'j', ctrl: true },
+];
+const UNDO = [
+    { key: '-', ctrl: true }, // kitty 轨规范形
+    { key: '_', ctrl: true }, // legacy 轨 0x1f 解码形
+];
+const MOVE_LEFT = [{ key: 'left' }, { key: 'b', ctrl: true }];
+const MOVE_RIGHT = [{ key: 'right' }, { key: 'f', ctrl: true }];
+const MOVE_WORD_LEFT = [
+    { key: 'left', alt: true },
+    { key: 'left', ctrl: true },
+    { key: 'b', alt: true },
+];
+const MOVE_WORD_RIGHT = [
+    { key: 'right', alt: true },
+    { key: 'right', ctrl: true },
+    { key: 'f', alt: true },
+];
+const LINE_START = [{ key: 'home' }, { key: 'a', ctrl: true }];
+const LINE_END = [{ key: 'end' }, { key: 'e', ctrl: true }];
+const JUMP_FORWARD = [{ key: ']', ctrl: true }];
+const JUMP_BACKWARD = [{ key: ']', ctrl: true, alt: true }];
+const PAGE_UP = [{ key: 'pageup' }];
+const PAGE_DOWN = [{ key: 'pagedown' }];
+const DELETE_BACKWARD = [{ key: 'backspace' }];
+const DELETE_FORWARD = [{ key: 'delete' }, { key: 'd', ctrl: true }];
+const DELETE_WORD_BACKWARD = [
+    { key: 'w', ctrl: true },
+    { key: 'backspace', alt: true },
+];
+const DELETE_WORD_FORWARD = [
+    { key: 'd', alt: true },
+    { key: 'delete', alt: true },
+];
+const DELETE_TO_LINE_START = [{ key: 'u', ctrl: true }];
+const DELETE_TO_LINE_END = [{ key: 'k', ctrl: true }];
+const HISTORY_PREV = [{ key: 'up' }];
+const HISTORY_NEXT = [{ key: 'down' }];
+/** 键位匹配（单字符键名大小写不敏感归一——shift 产大写形） */
+function matches(e, b) {
+    if (e.meta)
+        return false;
+    if (e.ctrl !== !!b.ctrl || e.alt !== !!b.alt || e.shift !== !!b.shift)
+        return false;
+    if (e.key === b.key)
+        return true;
+    return e.key.length === 1 && b.key.length === 1 && e.key.toLowerCase() === b.key;
+}
+function matchesAny(e, bindings) {
+    return bindings.some((b) => matches(e, b));
+}
+/** 可打印字符键判（jump 待靶态的靶字符判据——无修饰或仅 shift） */
+function isPlainCharKey(e) {
+    return e.key.length === 1 && !e.ctrl && !e.alt && !e.meta;
+}
+/**
+ * 多行输入组件：状态归模型、呈现归视图、本件只做事件分发与装配面。
+ */
+export class Editor {
+    model;
+    view;
+    /** jump 待靶方向（null = 常态） */
+    jumpPending = null;
+    onSubmit;
+    pageSize;
+    constructor(options = {}) {
+        this.onSubmit = options.onSubmit;
+        this.pageSize = Math.max(1, options.maxVisibleLines ?? 8);
+        this.model = new EditorModel();
+        this.model.onChange = (text) => options.onChange?.(text);
+        this.view = new EditorView(this.model, { maxVisibleLines: options.maxVisibleLines });
+    }
+    /* ---------------- 装配面便捷委托 ---------------- */
+    /** 聚焦态切换（事件路由器裁决） */
+    setFocused(focused) {
+        this.view.setFocused(focused);
+    }
+    getText() {
+        return this.model.getText();
+    }
+    setText(text) {
+        this.model.setText(text);
+    }
+    /* ---------------- 渲染委托（两段协商直通视图） ---------------- */
+    measure(width) {
+        return this.view.measure(width);
+    }
+    render(buffer, region) {
+        this.view.render(buffer, region);
+    }
+    /* ---------------- 输入事件分发 ---------------- */
+    /** 四路分发：返回是否消费（false = 归上层，如 ctrl+c 的 abort 路） */
+    handleEvent(event) {
+        switch (event.kind) {
+            case 'key':
+                return this.handleKey(event);
+            case 'text': {
+                // jump 待靶态：首字符为跳转靶（kitty / legacy 可打印均走 text 事件）
+                if (this.jumpPending !== null && event.text.length > 0) {
+                    this.model.jumpToChar([...event.text][0], this.jumpPending);
+                    this.jumpPending = null;
+                    return true;
+                }
+                this.model.insertText(event.text);
+                return true;
+            }
+            case 'ime':
+                if (event.committed) {
+                    this.model.setPreedit(null);
+                    this.model.insertText(event.text);
+                }
+                else {
+                    this.model.setPreedit(event.text);
+                }
+                return true;
+            case 'paste':
+                // 整段入正文（规范条款——无标记机制，多行粘贴直接呈现）
+                this.jumpPending = null;
+                this.model.insertText(event.text);
+                return true;
+            case 'mouse':
+                return false; // 主屏零鼠标（07 屏模型注）——到达即吞不消费（副屏选区路不经本件）
+        }
+    }
+    /** 键事件路（release 相不动作；ctrl+c 显式透传） */
+    handleKey(e) {
+        if (e.phase === 'release')
+            return false; // 释放相归上层（不消费）
+        // jump 待靶态：escape 取消、可打印字符为靶（key 路防御位——text 路为主）
+        if (this.jumpPending !== null) {
+            if (matchesAny(e, [{ key: 'escape' }])) {
+                this.jumpPending = null;
+                return true;
+            }
+            if (isPlainCharKey(e)) {
+                this.model.jumpToChar(e.key, this.jumpPending);
+                this.jumpPending = null;
+                return true;
+            }
+        }
+        if (e.ctrl && !e.alt && !e.shift && !e.meta && e.key === 'c')
+            return false; // ctrl+c 透传上层 abort
+        if (matchesAny(e, SUBMIT))
+            return this.handleSubmit();
+        if (matchesAny(e, NEW_LINE)) {
+            this.jumpPending = null;
+            this.model.addNewLine();
+            return true;
+        }
+        if (matchesAny(e, UNDO)) {
+            this.jumpPending = null;
+            this.model.undo();
+            return true;
+        }
+        if (matchesAny(e, MOVE_LEFT)) {
+            this.jumpPending = null;
+            this.model.moveLeft();
+            return true;
+        }
+        if (matchesAny(e, MOVE_RIGHT)) {
+            this.jumpPending = null;
+            this.model.moveRight();
+            return true;
+        }
+        if (matchesAny(e, MOVE_WORD_LEFT)) {
+            this.jumpPending = null;
+            this.model.moveWordBackward();
+            return true;
+        }
+        if (matchesAny(e, MOVE_WORD_RIGHT)) {
+            this.jumpPending = null;
+            this.model.moveWordForward();
+            return true;
+        }
+        if (matchesAny(e, LINE_START)) {
+            this.jumpPending = null;
+            this.model.moveHome();
+            return true;
+        }
+        if (matchesAny(e, LINE_END)) {
+            this.jumpPending = null;
+            this.model.moveEnd();
+            return true;
+        }
+        if (matchesAny(e, JUMP_FORWARD)) {
+            this.jumpPending = 'forward';
+            return true;
+        }
+        if (matchesAny(e, JUMP_BACKWARD)) {
+            this.jumpPending = 'backward';
+            return true;
+        }
+        if (matchesAny(e, PAGE_UP)) {
+            this.jumpPending = null;
+            this.model.pageUp(this.pageSize);
+            return true;
+        }
+        if (matchesAny(e, PAGE_DOWN)) {
+            this.jumpPending = null;
+            this.model.pageDown(this.pageSize);
+            return true;
+        }
+        if (matchesAny(e, DELETE_BACKWARD)) {
+            this.jumpPending = null;
+            this.model.backspace();
+            return true;
+        }
+        if (matchesAny(e, DELETE_FORWARD)) {
+            this.jumpPending = null;
+            this.model.deleteForward();
+            return true;
+        }
+        if (matchesAny(e, DELETE_WORD_BACKWARD)) {
+            this.jumpPending = null;
+            this.model.deleteWordBackward();
+            return true;
+        }
+        if (matchesAny(e, DELETE_WORD_FORWARD)) {
+            this.jumpPending = null;
+            this.model.deleteWordForward();
+            return true;
+        }
+        if (matchesAny(e, DELETE_TO_LINE_START)) {
+            this.jumpPending = null;
+            this.model.deleteToLineStart();
+            return true;
+        }
+        if (matchesAny(e, DELETE_TO_LINE_END)) {
+            this.jumpPending = null;
+            this.model.deleteToLineEnd();
+            return true;
+        }
+        if (matchesAny(e, HISTORY_PREV)) {
+            this.jumpPending = null;
+            // 首视觉行 +（空框 / 已在浏览态 / 逻辑行首）→ 历史回溯；否则视觉行上移
+            const cursor = this.model.getCursor();
+            if (this.model.isOnFirstVisualLine() &&
+                (this.model.isEmpty() || this.model.isBrowsingHistory() || cursor.col === 0)) {
+                this.model.navigateHistory(-1);
+            }
+            else {
+                this.model.moveUp();
+            }
+            return true;
+        }
+        if (matchesAny(e, HISTORY_NEXT)) {
+            this.jumpPending = null;
+            // 末视觉行 → 历史回新（含回草稿）；否则视觉行下移
+            if (this.model.isOnLastVisualLine()) {
+                this.model.navigateHistory(1);
+            }
+            else {
+                this.model.moveDown();
+            }
+            return true;
+        }
+        return false; // 未绑定键归上层（escape / f 键 / tab…）
+    }
+    /** 提交：模型全清取文、非空才入册 + 回调 */
+    handleSubmit() {
+        this.jumpPending = null;
+        const text = this.model.submit();
+        if (text !== '') {
+            this.model.addToHistory(text);
+            this.onSubmit?.(text);
+        }
+        return true;
+    }
+}

package/dist/channels/tui/editor/undo-stack.js

@@ -0,0 +1,35 @@
+/**
+ * 泛型 undo 栈（多行输入件 Editor 件族基件——07 §4.1 引擎节件 6（组件与呈现装配件）
+ * 「undo 上限收 v1」条款的载体）。
+ *
+ * clone-on-push：入栈即深拷贝快照（structuredClone），弹出直付（已脱钩
+ * 无需再拷）；上限超量丢最旧（上限值码面定 100——与输入历史帽同值，
+ * 规范只钉「有上限」不收数字）。
+ */
+/** 快照类型约束：可 structuredClone 的纯数据形 */
+// （泛型约束不写死——structuredClone 接受任意可克隆值，调用面以类型保证）
+/** undo 栈：深拷贝快照栈 + 上帽丢最旧 */
+export class UndoStack {
+    limit;
+    stack = [];
+    constructor(limit = 100) {
+        this.limit = limit;
+    }
+    /** 深拷贝入栈（超帽丢最旧——最近编辑永远可撤） */
+    push(state) {
+        this.stack.push(structuredClone(state));
+        if (this.stack.length > this.limit)
+            this.stack.shift();
+    }
+    /** 弹出最近快照（空栈 undefined） */
+    pop() {
+        return this.stack.pop();
+    }
+    /** 清空（提交后弃撤回域） */
+    clear() {
+        this.stack.length = 0;
+    }
+    get length() {
+        return this.stack.length;
+    }
+}

package/dist/channels/tui/editor/visual-lines.js

@@ -0,0 +1,126 @@
+/**
+ * 视觉行映射纯函数（多行输入件 Editor 件族基件）：逻辑行 → 折行后视觉行
+ * 的映射单源（垂直光标移动 / 视口滚动 / 渲染三消费方共用）。
+ *
+ * 本仓化关键差异（07 引擎节件 6（组件与呈现装配件）「字素光标算术——CJK 双宽对齐」条款）：
+ * - 折行按**显示列宽**（字素 graphemeWidth 累计、整字下移不产半字——与引擎
+ *   width 件 wrapText 同规则），段记录 UTF-16 下标面（startCol/length 供
+ *   字符串切片）+ 显示宽面（width 供视觉列算术）双坐标；
+ * - 垂直移动的视觉列 = **显示列**（光标前字素列宽和），非 UTF-16 码元差
+ *   （pi 以码元差近似，CJK 双宽下 sticky 列漂移——本仓按规范双宽对齐）。
+ */
+import { graphemeWidth, splitGraphemes } from '../../engine/index.js';
+/**
+ * 单逻辑行按显示宽硬折（字素累宽超限整字下移——空行占一段零宽）。
+ * 返回段的 UTF-16 与显示宽双坐标。
+ */
+function foldLine(line, lineNo, width) {
+    if (width <= 0)
+        return [{ line: lineNo, startCol: 0, length: line.length, width: 0 }];
+    if (line === '')
+        return [{ line: lineNo, startCol: 0, length: 0, width: 0 }];
+    const segments = [];
+    let start = 0; // 当前段 UTF-16 起点
+    let usedCols = 0; // 当前段已占显示宽
+    let segLen = 0; // 当前段 UTF-16 长
+    for (const g of splitGraphemes(line)) {
+        const w = graphemeWidth(g);
+        if (usedCols + w > width) {
+            segments.push({ line: lineNo, startCol: start, length: segLen, width: usedCols });
+            start += segLen;
+            segLen = g.length;
+            usedCols = w;
+        }
+        else {
+            segLen += g.length;
+            usedCols += w;
+        }
+    }
+    segments.push({ line: lineNo, startCol: start, length: segLen, width: usedCols });
+    return segments;
+}
+/** 全文档视觉行映射（逻辑行逐行硬折串接） */
+export function buildVisualLineMap(lines, width) {
+    const out = [];
+    for (let i = 0; i < lines.length; i++)
+        out.push(...foldLine(lines[i] ?? '', i, width));
+    return out;
+}
+/**
+ * 定位逻辑位置所在视觉行下标（col 为 UTF-16）。
+ * 逻辑行末段的末位（col = 行长）属末段——光标在行尾不落「下一段开头」。
+ */
+export function findVisualLineAt(map, line, col) {
+    for (let i = 0; i < map.length; i++) {
+        const vl = map[i];
+        if (vl.line !== line)
+            continue;
+        const offset = col - vl.startCol;
+        const isLastOfLine = i === map.length - 1 || map[i + 1].line !== vl.line;
+        if (offset >= 0 && (offset < vl.length || (isLastOfLine && offset === vl.length)))
+            return i;
+    }
+    return map.length - 1;
+}
+/**
+ * 段内显示列反查 UTF-16 下标：从段起点起累计字素宽，到目标显示列 targetCols
+ * 的字素边界（**光标永不落半字**——目标列落在宽字素中间时吸到其首列前，
+ * 返回该字素起点的 UTF-16 下标）。targetCols 超段宽返回段尾下标。
+ */
+export function colAtDisplayColumn(line, startCol, targetCols) {
+    let used = 0;
+    let idx = startCol;
+    for (const g of splitGraphemes(line.slice(startCol))) {
+        const w = graphemeWidth(g);
+        if (used + w > targetCols)
+            return idx; // 目标列落在本字素内——吸到首列前（半字防线）
+        used += w;
+        idx += g.length;
+    }
+    return idx;
+}
+/**
+ * 位置前缀显示宽：line 内 [0, col) 前缀的字素列宽和（光标视觉列算术的
+ * 单源——渲染光标定位 / sticky 列共用）。
+ */
+export function prefixDisplayWidth(line, col) {
+    let used = 0;
+    let idx = 0;
+    for (const g of splitGraphemes(line)) {
+        if (idx >= col)
+            break;
+        used += graphemeWidth(g);
+        idx += g.length;
+    }
+    return used;
+}
+/**
+ * 光标前一个字素的边界（UTF-16）：backspace / moveLeft 的字素算术。
+ * col 已在行首返回 0。
+ */
+export function prevGraphemeBoundary(line, col) {
+    if (col <= 0)
+        return 0;
+    let idx = 0;
+    let prev = 0;
+    for (const g of splitGraphemes(line)) {
+        if (idx >= col)
+            return prev;
+        prev = idx;
+        idx += g.length;
+    }
+    return prev;
+}
+/**
+ * 光标后一个字素的终点（UTF-16）：deleteForward / moveRight 的字素算术。
+ * col 已在行尾返回 line.length。
+ */
+export function nextGraphemeBoundary(line, col) {
+    let idx = 0;
+    for (const g of splitGraphemes(line)) {
+        if (idx >= col)
+            return idx + g.length;
+        idx += g.length;
+    }
+    return line.length;
+}

package/dist/channels/tui/editor/word-nav.js

@@ -0,0 +1,106 @@
+/**
+ * 词级导航纯函数（多行输入件 Editor 件族基件）：findWordBackward /
+ * findWordForward——词级删除与词向移动共用的边界判定单源。
+ *
+ * 机制语义承 pi word-navigation.ts（裁 ⓪ 从零重写）：
+ * - Intl.Segmenter **word 粒度**切词（与引擎 width 件的 grapheme 粒度不同
+ *   面——此处自持单例）；
+ * - isWordLike 三分支：词内含 ASCII 标点时切到标点边界（foo.bar 一步到
+ *   '.' 前）、非词非空白的标点 run 整段跳、空白跳过；
+ * - 纯函数零状态——调用方（编辑模型）自持光标。
+ */
+const wordSegmenter = new Intl.Segmenter(undefined, { granularity: 'word' });
+/** ASCII 标点判（词内边界细化用——POSIX 图形字符中的非字母数字段） */
+function isPunctuation(ch) {
+    const c = ch.charCodeAt(0);
+    return (c >= 0x21 && c <= 0x2f) || (c >= 0x3a && c <= 0x40) || (c >= 0x5b && c <= 0x60) || (c >= 0x7b && c <= 0x7e);
+}
+/** 词粒度分段（字素串 + isWordLike 标记） */
+function segmentWords(text) {
+    const out = [];
+    for (const seg of wordSegmenter.segment(text)) {
+        out.push({ segment: seg.segment, isWordLike: seg.isWordLike === true });
+    }
+    return out;
+}
+/** 空白判（词导航语义的空白 = 空白段整体跳过） */
+function isWhitespace(text) {
+    return text.length > 0 && text.trim().length === 0;
+}
+/**
+ * 光标向后移一词：跳过尾部空白，再跳一词（词内含 ASCII 标点切到最近标点
+ * 边界、标点 run 整段跳）。返回新光标（UTF-16 下标）——纯函数不改入参。
+ */
+export function findWordBackward(text, cursor) {
+    if (cursor <= 0)
+        return 0;
+    const segments = segmentWords(text.slice(0, cursor));
+    let newCursor = cursor;
+    // 先跳尾部空白段
+    while (segments.length > 0 && isWhitespace(segments[segments.length - 1].segment)) {
+        newCursor -= segments.pop().segment.length;
+    }
+    if (segments.length === 0)
+        return newCursor;
+    const last = segments[segments.length - 1];
+    if (last.isWordLike) {
+        // 词内含 ASCII 标点：切到词内最后一段标点之后（foo.bar → '.' 前）
+        const segment = last.segment;
+        let cut = -1;
+        for (let ci = 0; ci < segment.length; ci++) {
+            if (isPunctuation(segment[ci]))
+                cut = ci + 1;
+        }
+        if (cut >= 0)
+            newCursor -= segment.length - cut;
+        else
+            newCursor -= segment.length;
+    }
+    else {
+        // 非词非空白 run（标点串）整段跳
+        while (segments.length > 0 &&
+            !segments[segments.length - 1].isWordLike &&
+            !isWhitespace(segments[segments.length - 1].segment)) {
+            newCursor -= segments.pop().segment.length;
+        }
+    }
+    return newCursor;
+}
+/**
+ * 光标向前移一词：跳过前导空白，再跳一词（词内标点切到首个标点前、
+ * 标点 run 整段跳）。返回新光标（UTF-16 下标）——纯函数。
+ */
+export function findWordForward(text, cursor) {
+    if (cursor >= text.length)
+        return text.length;
+    const segments = segmentWords(text.slice(cursor));
+    let newCursor = cursor;
+    let i = 0;
+    // 先跳前导空白段
+    while (i < segments.length && isWhitespace(segments[i].segment)) {
+        newCursor += segments[i].segment.length;
+        i++;
+    }
+    if (i >= segments.length)
+        return newCursor;
+    const first = segments[i];
+    if (first.isWordLike) {
+        // 词内含 ASCII 标点：切到词内首个标点前（bar.baz → '.' 前）
+        let stop = -1;
+        for (let ci = 0; ci < first.segment.length; ci++) {
+            if (isPunctuation(first.segment[ci])) {
+                stop = ci;
+                break;
+            }
+        }
+        newCursor += stop >= 0 ? stop : first.segment.length;
+    }
+    else {
+        // 非词非空白 run（标点串）整段跳
+        while (i < segments.length && !segments[i].isWordLike && !isWhitespace(segments[i].segment)) {
+            newCursor += segments[i].segment.length;
+            i++;
+        }
+    }
+    return newCursor;
+}