@gitim-runtime/cli 0.1.0

package/dist/tui/app.js

@@ -0,0 +1,461 @@
+/**
+ * TUI 主应用 — 组装所有组件并管理交互
+ */
+import { TUI, ProcessTerminal, Editor, matchesKey, Key } from '@mariozechner/pi-tui';
+import { DaemonConnection } from './daemon-connection.js';
+import { ChannelSidebar, SIDEBAR_WIDTH } from './channel-sidebar.js';
+import { MessageView } from './message-view.js';
+import { SplitLayout } from './split-layout.js';
+import { StatusBar } from './status-bar.js';
+import { ThreadView } from './thread-view.js';
+import { MentionPopup } from './mention-popup.js';
+import { editorTheme } from './themes.js';
+export class TuiApp {
+    tui;
+    terminal;
+    conn;
+    user;
+    repoRoot;
+    // 组件
+    sidebar;
+    messageView;
+    editor;
+    statusBar;
+    splitLayout;
+    threadView;
+    mentionPopup;
+    // 状态
+    mode = 'normal';
+    users = [];
+    threadOverlay = null;
+    mentionOverlay = null;
+    mentionFilter = '';
+    loadMessagesInFlight = false;
+    loadMessagesPending = false;
+    constructor(options) {
+        this.repoRoot = options.repoRoot;
+        this.user = options.user;
+        this.terminal = new ProcessTerminal();
+        this.tui = new TUI(this.terminal);
+        this.conn = new DaemonConnection(this.repoRoot);
+        // 初始化组件
+        this.sidebar = new ChannelSidebar();
+        this.messageView = new MessageView();
+        this.editor = new Editor(this.tui, editorTheme);
+        this.statusBar = new StatusBar();
+        this.threadView = new ThreadView();
+        this.mentionPopup = new MentionPopup();
+        this.splitLayout = new SplitLayout(this.sidebar, this.messageView, SIDEBAR_WIDTH);
+        // 配置状态栏
+        this.statusBar.user = this.user;
+        this.statusBar.mode = 'normal';
+        // 配置 Editor
+        this.editor.onSubmit = (text) => {
+            this.sendMessage(text);
+        };
+        // 配置线程视图回调
+        this.threadView.onReply = (msg) => {
+            this.statusBar.replyTarget = msg.line_number;
+            this.closeThread();
+            this.setMode('normal');
+            this.tui.requestRender();
+        };
+        this.threadView.onClose = () => {
+            this.closeThread();
+        };
+        // 配置提及弹窗回调
+        this.mentionPopup.onSelect = (user) => {
+            this.editor.insertTextAtCursor(user + ' ');
+            this.closeMention();
+        };
+        this.mentionPopup.onCancel = () => {
+            this.closeMention();
+        };
+        // 推送事件处理
+        this.conn.onEvent = (event) => {
+            if (event.event === 'thread_changed' && event.channel === this.sidebar.currentChannel) {
+                this.loadMessages();
+            }
+            else if (event.event === 'thread_changed' && event.channel !== this.sidebar.currentChannel) {
+                // 更新未读计数
+                const count = this.sidebar.unreadCounts.get(event.channel) ?? 0;
+                this.sidebar.unreadCounts.set(event.channel, count + 1);
+                this.tui.requestRender();
+            }
+        };
+        // 全局输入监听
+        this.tui.addInputListener((data) => {
+            return this.handleGlobalInput(data);
+        });
+    }
+    async start() {
+        // 连接 daemon
+        try {
+            await this.conn.connect(true);
+            this.statusBar.connected = true;
+        }
+        catch (e) {
+            this.statusBar.connected = false;
+        }
+        // 加载频道和用户
+        await this.loadChannels();
+        await this.loadUsers();
+        // 加载第一个频道的消息
+        if (this.sidebar.channels.length > 0) {
+            this.statusBar.channel = this.sidebar.currentChannel;
+            await this.loadMessages();
+        }
+        // 组装布局：SplitLayout + Editor + StatusBar
+        this.tui.addChild(this.splitLayout);
+        this.tui.addChild(this.editor);
+        this.tui.addChild(this.statusBar);
+        // 设置焦点到 Editor
+        this.tui.setFocus(this.editor);
+        // 计算布局高度
+        this.updateLayoutHeight();
+        // 启动 TUI
+        this.tui.start();
+        this.tui.requestRender();
+        // 监听终端大小变化
+        process.stdout.on('resize', () => {
+            this.updateLayoutHeight();
+            this.tui.requestRender();
+        });
+    }
+    updateLayoutHeight() {
+        const totalH = this.terminal.rows;
+        // 状态栏 1 行，Editor 约 3 行（边框+内容）
+        this.splitLayout.height = Math.max(1, totalH - 4);
+    }
+    handleGlobalInput(data) {
+        // Ctrl+Q 退出
+        if (matchesKey(data, Key.ctrl('q'))) {
+            this.shutdown();
+            return { consume: true };
+        }
+        // 提及弹窗活动时
+        if (this.mentionOverlay) {
+            // Esc/Enter/↑↓ 由弹窗处理
+            if (matchesKey(data, Key.escape) || matchesKey(data, Key.enter) ||
+                matchesKey(data, Key.up) || matchesKey(data, Key.down)) {
+                this.mentionPopup.handleInput(data);
+                this.tui.requestRender();
+                return { consume: true };
+            }
+            // Backspace 更新过滤词
+            if (matchesKey(data, Key.backspace)) {
+                if (this.mentionFilter.length > 0) {
+                    this.mentionFilter = this.mentionFilter.slice(0, -1);
+                    this.mentionPopup.setFilter(this.mentionFilter);
+                }
+                else {
+                    this.closeMention();
+                }
+                this.tui.requestRender();
+                // 不消费，让 editor 也处理 backspace
+                return undefined;
+            }
+            // 普通字符输入 → 更新过滤词，同时让字符进入 editor
+            if (data.length === 1 && data >= ' ') {
+                if (data === ' ') {
+                    // 空格关闭弹窗
+                    this.closeMention();
+                }
+                else {
+                    this.mentionFilter += data;
+                    this.mentionPopup.setFilter(this.mentionFilter);
+                    this.tui.requestRender();
+                }
+                return undefined; // 让 editor 也收到字符
+            }
+            // 其他键交给弹窗
+            this.mentionPopup.handleInput(data);
+            this.tui.requestRender();
+            return { consume: true };
+        }
+        // 线程模式
+        if (this.mode === 'chain') {
+            return this.handleChainInput(data);
+        }
+        // 浏览模式
+        if (this.mode === 'browse') {
+            return this.handleBrowseInput(data);
+        }
+        // 普通模式
+        return this.handleNormalInput(data);
+    }
+    handleNormalInput(data) {
+        // Ctrl+B 进入浏览模式
+        if (matchesKey(data, Key.ctrl('b'))) {
+            this.setMode('browse');
+            return { consume: true };
+        }
+        // Alt+↑/↓ 切换频道
+        if (matchesKey(data, Key.alt('up'))) {
+            this.sidebar.moveUp();
+            this.onChannelChanged();
+            return { consume: true };
+        }
+        if (matchesKey(data, Key.alt('down'))) {
+            this.sidebar.moveDown();
+            this.onChannelChanged();
+            return { consume: true };
+        }
+        // Alt+1~9 跳转频道
+        const digits = ['1', '2', '3', '4', '5', '6', '7', '8', '9'];
+        for (let i = 0; i < digits.length; i++) {
+            if (matchesKey(data, Key.alt(digits[i]))) {
+                this.sidebar.jumpTo(i);
+                this.onChannelChanged();
+                return { consume: true };
+            }
+        }
+        // @ 触发提及弹窗（在 editor 有焦点时）
+        if (data === '@') {
+            this.showMention();
+            // 不消费，让 @ 字符进入 editor
+            return undefined;
+        }
+        // 不消费，让 editor 处理
+        return undefined;
+    }
+    handleBrowseInput(data) {
+        if (matchesKey(data, Key.escape)) {
+            this.setMode('normal');
+            return { consume: true };
+        }
+        if (data === 'j' || matchesKey(data, Key.down)) {
+            this.messageView.moveDown();
+            this.tui.requestRender();
+            return { consume: true };
+        }
+        if (data === 'k' || matchesKey(data, Key.up)) {
+            this.messageView.moveUp();
+            this.tui.requestRender();
+            return { consume: true };
+        }
+        if (data === 'G') {
+            this.messageView.jumpToBottom();
+            this.tui.requestRender();
+            return { consume: true };
+        }
+        if (data === 'r') {
+            const msg = this.messageView.messages[this.messageView.selectedIndex];
+            if (msg) {
+                this.statusBar.replyTarget = msg.line_number;
+                this.setMode('normal');
+            }
+            return { consume: true };
+        }
+        if (matchesKey(data, Key.enter)) {
+            const msg = this.messageView.messages[this.messageView.selectedIndex];
+            if (msg) {
+                this.showThread(msg);
+            }
+            return { consume: true };
+        }
+        // Alt+↑/↓ 切换频道（在浏览模式也生效）
+        if (matchesKey(data, Key.alt('up'))) {
+            this.sidebar.moveUp();
+            this.onChannelChanged();
+            return { consume: true };
+        }
+        if (matchesKey(data, Key.alt('down'))) {
+            this.sidebar.moveDown();
+            this.onChannelChanged();
+            return { consume: true };
+        }
+        return { consume: true }; // 浏览模式消费所有输入
+    }
+    handleChainInput(data) {
+        if (matchesKey(data, Key.escape)) {
+            this.closeThread();
+            return { consume: true };
+        }
+        if (data === 'j' || matchesKey(data, Key.down)) {
+            this.threadView.moveDown();
+            this.tui.requestRender();
+            return { consume: true };
+        }
+        if (data === 'k' || matchesKey(data, Key.up)) {
+            this.threadView.moveUp();
+            this.tui.requestRender();
+            return { consume: true };
+        }
+        if (data === 'r') {
+            const msg = this.threadView.messages[this.threadView.selectedIndex];
+            if (msg) {
+                this.statusBar.replyTarget = msg.line_number;
+                this.closeThread();
+                this.setMode('normal');
+            }
+            return { consume: true };
+        }
+        return { consume: true };
+    }
+    setMode(mode) {
+        this.mode = mode;
+        this.statusBar.mode = mode;
+        if (mode === 'normal') {
+            this.messageView.exitBrowse();
+            this.tui.setFocus(this.editor);
+        }
+        else if (mode === 'browse') {
+            this.messageView.enterBrowse();
+            this.tui.setFocus(null);
+        }
+        else if (mode === 'chain') {
+            this.tui.setFocus(null);
+        }
+        this.tui.requestRender();
+    }
+    async sendMessage(text) {
+        this.statusBar.error = null;
+        const trimmed = text.trim();
+        if (!trimmed)
+            return;
+        const channel = this.sidebar.currentChannel;
+        if (!channel)
+            return;
+        const params = {
+            channel,
+            body: trimmed,
+            author: this.user,
+        };
+        if (this.statusBar.replyTarget) {
+            params.reply_to = this.statusBar.replyTarget;
+            this.statusBar.replyTarget = null;
+        }
+        try {
+            const res = await this.conn.request('send', params);
+            if (res.ok) {
+                this.editor.setText('');
+                await this.loadMessages();
+            }
+            else {
+                this.statusBar.error = res.error ?? '发送失败';
+                this.tui.requestRender();
+            }
+        }
+        catch (e) {
+            this.statusBar.error = e.message ?? '发送失败';
+            this.tui.requestRender();
+        }
+    }
+    async loadChannels() {
+        try {
+            const res = await this.conn.request('channels');
+            if (res.ok && res.data?.channels) {
+                this.sidebar.channels = res.data.channels;
+            }
+        }
+        catch {
+            // 忽略
+        }
+    }
+    async loadUsers() {
+        try {
+            const res = await this.conn.request('users');
+            if (res.ok && res.data?.users) {
+                this.users = res.data.users;
+                this.mentionPopup.allUsers = this.users;
+            }
+        }
+        catch {
+            // 忽略
+        }
+    }
+    async loadMessages() {
+        const channel = this.sidebar.currentChannel;
+        if (!channel)
+            return;
+        // 防止并发请求导致 FIFO 响应错配
+        if (this.loadMessagesInFlight) {
+            this.loadMessagesPending = true;
+            return;
+        }
+        this.loadMessagesInFlight = true;
+        try {
+            const res = await this.conn.request('read', { channel, limit: 50, since: 0 });
+            if (res.ok && res.data?.messages) {
+                this.messageView.messages = res.data.messages;
+                this.tui.requestRender();
+            }
+        }
+        catch {
+            // 忽略
+        }
+        finally {
+            this.loadMessagesInFlight = false;
+            // 如果有待处理的请求，执行最后一次
+            if (this.loadMessagesPending) {
+                this.loadMessagesPending = false;
+                this.loadMessages();
+            }
+        }
+    }
+    onChannelChanged() {
+        this.statusBar.channel = this.sidebar.currentChannel;
+        this.statusBar.replyTarget = null;
+        this.sidebar.unreadCounts.delete(this.sidebar.currentChannel);
+        this.messageView.messages = [];
+        this.messageView.exitBrowse();
+        this.loadMessages();
+        this.tui.requestRender();
+    }
+    async showThread(msg) {
+        try {
+            const res = await this.conn.request('thread', {
+                channel: this.sidebar.currentChannel,
+                line_number: msg.line_number,
+            });
+            if (res.ok && res.data?.messages) {
+                this.threadView.messages = res.data.messages;
+                this.threadView.rootLine = msg.line_number;
+                this.threadView.selectedIndex = 0;
+                this.threadOverlay = this.tui.showOverlay(this.threadView, {
+                    anchor: 'center',
+                    width: '70%',
+                    maxHeight: '60%',
+                });
+                this.setMode('chain');
+            }
+        }
+        catch {
+            // 忽略
+        }
+    }
+    closeThread() {
+        if (this.threadOverlay) {
+            this.threadOverlay.hide();
+            this.threadOverlay = null;
+        }
+        if (this.mode === 'chain') {
+            this.setMode('browse');
+        }
+    }
+    showMention() {
+        this.mentionFilter = '';
+        this.mentionPopup.setFilter('');
+        this.mentionOverlay = this.tui.showOverlay(this.mentionPopup, {
+            anchor: 'bottom-left',
+            width: 30,
+            maxHeight: 12,
+            offsetY: -4,
+            offsetX: SIDEBAR_WIDTH + 2,
+        });
+        this.tui.requestRender();
+    }
+    closeMention() {
+        if (this.mentionOverlay) {
+            this.mentionOverlay.hide();
+            this.mentionOverlay = null;
+        }
+        this.tui.requestRender();
+    }
+    shutdown() {
+        this.conn.disconnect();
+        this.tui.stop();
+        process.exit(0);
+    }
+}

package/dist/tui/channel-sidebar.d.ts

@@ -0,0 +1,14 @@
+import { type Component } from '@mariozechner/pi-tui';
+export declare const SIDEBAR_WIDTH = 20;
+export declare class ChannelSidebar implements Component {
+    channels: string[];
+    currentIndex: number;
+    unreadCounts: Map<string, number>;
+    invalidate(): void;
+    get currentChannel(): string;
+    selectChannel(name: string): boolean;
+    moveUp(): void;
+    moveDown(): void;
+    jumpTo(n: number): void;
+    render(width: number): string[];
+}

package/dist/tui/channel-sidebar.js

@@ -0,0 +1,62 @@
+/**
+ * 频道侧边栏组件
+ */
+import chalk from 'chalk';
+import { truncateToWidth } from '@mariozechner/pi-tui';
+import { colors } from './themes.js';
+export const SIDEBAR_WIDTH = 20;
+export class ChannelSidebar {
+    channels = [];
+    currentIndex = 0;
+    unreadCounts = new Map();
+    invalidate() { }
+    get currentChannel() {
+        return this.channels[this.currentIndex] ?? '';
+    }
+    selectChannel(name) {
+        const idx = this.channels.indexOf(name);
+        if (idx >= 0) {
+            this.currentIndex = idx;
+            return true;
+        }
+        return false;
+    }
+    moveUp() {
+        if (this.currentIndex > 0)
+            this.currentIndex--;
+    }
+    moveDown() {
+        if (this.currentIndex < this.channels.length - 1)
+            this.currentIndex++;
+    }
+    jumpTo(n) {
+        if (n >= 0 && n < this.channels.length)
+            this.currentIndex = n;
+    }
+    render(width) {
+        const w = Math.min(width, SIDEBAR_WIDTH);
+        const lines = [];
+        // 标题
+        lines.push(truncateToWidth(chalk.bold(' 频道'), w));
+        lines.push(truncateToWidth(chalk.gray('─'.repeat(w)), w));
+        for (let i = 0; i < this.channels.length; i++) {
+            const ch = this.channels[i];
+            const unread = this.unreadCounts.get(ch) ?? 0;
+            const prefix = i === this.currentIndex ? '▸' : ' ';
+            let label = `${prefix} #${ch}`;
+            if (unread > 0) {
+                label += ` (${unread})`;
+            }
+            if (i === this.currentIndex) {
+                lines.push(truncateToWidth(colors.channelActive(label.padEnd(w)), w));
+            }
+            else if (unread > 0) {
+                lines.push(truncateToWidth(colors.unread(label.padEnd(w)), w));
+            }
+            else {
+                lines.push(truncateToWidth(colors.channelNormal(label.padEnd(w)), w));
+            }
+        }
+        return lines;
+    }
+}

package/dist/tui/daemon-connection.d.ts

@@ -0,0 +1,38 @@
+import { EventEmitter } from 'node:events';
+export interface ApiResponse {
+    ok: boolean;
+    data?: any;
+    error?: string;
+}
+export interface PushEvent {
+    event: string;
+    channel: string;
+    kind: string;
+}
+export interface Message {
+    line_number: number;
+    point_to: number;
+    author: string;
+    timestamp: string;
+    body: string;
+}
+export declare class DaemonConnection extends EventEmitter {
+    private socketPath;
+    private socket;
+    private rl;
+    private connected;
+    private subscribed;
+    private pendingRequests;
+    private requestId;
+    /** Callback for push events (set by consumer) */
+    onEvent: ((event: PushEvent) => void) | null;
+    constructor(repoRoot: string);
+    get isConnected(): boolean;
+    /** Connect to daemon and optionally subscribe for push events */
+    connect(subscribe?: boolean): Promise<void>;
+    /** Send a request and wait for response */
+    request(method: string, params?: Record<string, any>): Promise<ApiResponse>;
+    /** Disconnect from daemon */
+    disconnect(): void;
+    private handleLine;
+}

package/dist/tui/daemon-connection.js

@@ -0,0 +1,118 @@
+/**
+ * DaemonConnection — 持久连接 + 订阅推送
+ *
+ * 保持一个到 daemon 的长连接，支持：
+ * 1. request-response 模式（发送请求，等待响应）
+ * 2. subscribe 模式（接收实时推送事件）
+ */
+import net from 'node:net';
+import path from 'node:path';
+import readline from 'node:readline';
+import { EventEmitter } from 'node:events';
+export class DaemonConnection extends EventEmitter {
+    socketPath;
+    socket = null;
+    rl = null;
+    connected = false;
+    subscribed = false;
+    pendingRequests = new Map();
+    requestId = 0;
+    /** Callback for push events (set by consumer) */
+    onEvent = null;
+    constructor(repoRoot) {
+        super();
+        this.socketPath = path.join(repoRoot, '.gitim', 'run', 'gitim.sock');
+    }
+    get isConnected() {
+        return this.connected;
+    }
+    /** Connect to daemon and optionally subscribe for push events */
+    async connect(subscribe = true) {
+        return new Promise((resolve, reject) => {
+            this.socket = net.createConnection(this.socketPath);
+            this.socket.on('connect', async () => {
+                this.connected = true;
+                this.rl = readline.createInterface({ input: this.socket });
+                this.rl.on('line', (line) => {
+                    this.handleLine(line);
+                });
+                if (subscribe) {
+                    try {
+                        await this.request('subscribe');
+                        this.subscribed = true;
+                    }
+                    catch {
+                        // subscribe may not be available, continue without it
+                    }
+                }
+                this.emit('connected');
+                resolve();
+            });
+            this.socket.on('error', (err) => {
+                this.connected = false;
+                this.emit('error', err);
+                reject(new Error(`Cannot connect to daemon: ${err.message}`));
+            });
+            this.socket.on('close', () => {
+                this.connected = false;
+                this.subscribed = false;
+                this.emit('disconnected');
+            });
+        });
+    }
+    /** Send a request and wait for response */
+    async request(method, params = {}) {
+        if (!this.socket || !this.connected) {
+            throw new Error('Not connected to daemon');
+        }
+        return new Promise((resolve, reject) => {
+            const id = ++this.requestId;
+            const payload = JSON.stringify({ method, _req_id: id, ...params }) + '\n';
+            this.pendingRequests.set(id, { resolve, reject });
+            this.socket.write(payload);
+            // Timeout after 10 seconds
+            setTimeout(() => {
+                if (this.pendingRequests.has(id)) {
+                    this.pendingRequests.delete(id);
+                    reject(new Error(`Request timeout: ${method}`));
+                }
+            }, 10000);
+        });
+    }
+    /** Disconnect from daemon */
+    disconnect() {
+        if (this.rl) {
+            this.rl.close();
+            this.rl = null;
+        }
+        if (this.socket) {
+            this.socket.end();
+            this.socket = null;
+        }
+        this.connected = false;
+        this.subscribed = false;
+        this.pendingRequests.clear();
+    }
+    handleLine(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        // Check if this is a push event (has "event" field)
+        if (parsed.event) {
+            this.onEvent?.(parsed);
+            this.emit('push', parsed);
+            return;
+        }
+        // Otherwise it's a response — resolve the oldest pending request
+        // (daemon doesn't echo _req_id back, so we use FIFO order)
+        if (this.pendingRequests.size > 0) {
+            const [id, handler] = this.pendingRequests.entries().next().value;
+            this.pendingRequests.delete(id);
+            handler.resolve(parsed);
+        }
+    }
+}