elanous 0.2.34 → 0.2.36

package/src/tui/input/composer.ts

@@ -0,0 +1,151 @@
+import type { Key } from '../../tui.js';
+import { applyInlineEditorKey } from '../../input-core/inline-editor-key.js';
+import { createInlineEditorState, inlineEditorInsert, type InlineEditorState } from '../../input-core/inline-editor.js';
+import { safeLogText } from '../chat/log-view.js';
+
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+
+export type ComposerAction = 'edit' | 'submit' | 'cancel' | 'quit' | 'none';
+
+export interface ComposerResult {
+  readonly state: InlineEditorState;
+  readonly action: ComposerAction;
+  readonly submitted?: string;
+}
+
+export function emptyComposer(): InlineEditorState {
+  return createInlineEditorState();
+}
+
+/** Keep the edit cursor and the newest text visible in one terminal row. */
+export function composerViewport(state: InlineEditorState, columns: number): { line: string; cursorCol: number } {
+  const text = safeLogText(state.text).replace(/\n/g, '↵');
+  const before = safeLogText(state.text.slice(0, state.cursor)).replace(/\n/g, '↵');
+  const graphemes = Array.from(segmenter.segment(text), ({ segment }) => segment);
+  const cursorAt = Math.min(graphemes.length, Array.from(segmenter.segment(before)).length);
+  // Reserve one cell for the visible cursor after the prompt and text.
+  const available = Math.max(1, columns - 3);
+  let start = cursorAt;
+  let beforeWidth = 0;
+  while (start > 0) {
+    const cells = Bun.stringWidth(graphemes[start - 1]!);
+    if (beforeWidth + cells > available) break;
+    beforeWidth += cells;
+    start--;
+  }
+  let used = 0;
+  let end = start;
+  while (end < graphemes.length) {
+    const cells = Bun.stringWidth(graphemes[end]!);
+    if (used + cells > available) break;
+    used += cells;
+    end++;
+  }
+  return {
+    line: `❯ ${graphemes.slice(start, end).join('')}`,
+    cursorCol: Math.min(columns, 3 + beforeWidth),
+  };
+}
+
+export type WheelDirection = 'up' | 'down';
+
+/** Wheel notch carried by a parsed SGR mouse key; null for every other key. */
+export function wheelDirection(key: Key): WheelDirection | null {
+  if (key.name !== 'mouse') return null;
+  if (key.mouse?.type === 'scroll-up') return 'up';
+  if (key.mouse?.type === 'scroll-down') return 'down';
+  return null;
+}
+
+/**
+ * Longest pause allowed *inside* a held SGR tail. The tail itself may come any
+ * time after the lone ESC (the guard stays armed until the next key decides),
+ * but once characters are held, a pause this long releases them as typing.
+ */
+export const MOUSE_RESIDUE_WINDOW_MS = 500;
+const SGR_MOUSE_TAIL = /^\[<(\d+);(\d+);(\d+)([Mm])$/;
+const SGR_MOUSE_TAIL_PREFIX = /^\[(?:<(?:\d+(?:;(?:\d*|\d+;\d*))?)?)?$/;
+
+export type MouseResidueStep =
+  | { readonly kind: 'pass' }
+  | { readonly kind: 'hold' }
+  | { readonly kind: 'release'; readonly keys: readonly Key[] }
+  | { readonly kind: 'mouse'; readonly wheel: WheelDirection | null };
+
+/**
+ * When the ESC of an SGR mouse report reaches us apart from its tail (slow link,
+ * split write), the key parser's quiet window turns the ESC into Escape and the
+ * tail `[<65;10;5M` into typed characters. The guard is armed by that lone ESC;
+ * it holds the following characters while they still spell an SGR mouse tail,
+ * swallows a complete one (reporting its wheel notch), and releases anything
+ * else unchanged and in order.
+ */
+export class MouseResidueGuard {
+  private armedAt: number | null = null;
+  private held: Key[] = [];
+  private text = '';
+
+  arm(now: number): void {
+    this.armedAt = now;
+    this.held = [];
+    this.text = '';
+  }
+
+  accept(key: Key, now: number): MouseResidueStep {
+    if (this.armedAt === null) return { kind: 'pass' };
+    const ch = key.ctrl || key.alt || key.meta ? null : (key.raw ?? key.name);
+    const inTime = this.held.length === 0 || now - this.armedAt <= MOUSE_RESIDUE_WINDOW_MS;
+    const candidate = ch !== null && ch.length === 1 && inTime ? this.text + ch : null;
+    if (candidate !== null) {
+      const full = candidate.match(SGR_MOUSE_TAIL);
+      if (full) {
+        this.reset();
+        const button = Number(full[1]) & ~(4 | 8 | 16);
+        const pressed = full[4] === 'M';
+        return { kind: 'mouse', wheel: pressed && button === 64 ? 'up' : pressed && button === 65 ? 'down' : null };
+      }
+      if (SGR_MOUSE_TAIL_PREFIX.test(candidate)) {
+        this.held.push(key);
+        this.text = candidate;
+        this.armedAt = now;   // the pause limit counts from the last held character
+        return { kind: 'hold' };
+      }
+    }
+    const held = this.held;
+    this.reset();
+    return held.length === 0 ? { kind: 'pass' } : { kind: 'release', keys: [...held, key] };
+  }
+
+  private reset(): void {
+    this.armedAt = null;
+    this.held = [];
+    this.text = '';
+  }
+}
+
+/** Reuse the shared editor contract; only TUI submit/cancel keys live here. */
+export function applyComposerKey(state: InlineEditorState, key: Key): ComposerResult {
+  const name = key.name.toLowerCase();
+  // Mouse reports (wheel, click, drag) never edit the prompt.
+  if (name === 'mouse') return { state, action: 'none' };
+  if (name === 'escape' && !state.text) return { state, action: 'none' };
+  if ((key.ctrl && (name === 'd' || name === 'c')) || name === 'escape') {
+    if (state.text && !(key.ctrl && name === 'd')) return { state: emptyComposer(), action: 'cancel' };
+    return { state, action: 'quit' };
+  }
+  if ((name === 'enter' || name === 'return') && !key.shift) {
+    const submitted = state.text.trim();
+    return submitted
+      ? { state: emptyComposer(), action: 'submit', submitted }
+      : { state, action: 'none' };
+  }
+  // One bracketed-paste envelope (terminal paste · herdr `pane run`) is one key whose body rides on `paste`.
+  // Without this the shared text rule inserted the key NAME («paste») instead of the pasted text.
+  if (name === 'paste') {
+    return typeof key.paste === 'string' && key.paste.length > 0
+      ? { state: inlineEditorInsert(state, key.paste), action: 'edit' }
+      : { state, action: 'none' };
+  }
+  const edited = applyInlineEditorKey(state, key, { shiftEnter: 'newline', tab: null });
+  return edited ? { state: edited, action: 'edit' } : { state, action: 'none' };
+}

package/src/tui/seat-mail-boot.ts

@@ -0,0 +1,59 @@
+import { statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import type { MsgStore } from '../msg/msg-store.js';
+
+export interface SeatMailSnapshot {
+  seat: string;
+  unread: number | null;
+}
+
+const SEAT_IN_PATH = /(?:^|\/)seats\/([A-Za-z][A-Za-z0-9_-]{0,63})(?:\/|$)/;
+const SEAT_ID = /^[A-Z][A-Z0-9_-]{0,63}$/;
+
+/** A small, read-only snapshot for the next TUI's first frame. */
+export function readSeatMailSnapshot(
+  cwd: string,
+  deps: {
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    msgPath?: string;
+  } = {},
+): SeatMailSnapshot | null {
+  const env = deps.env ?? process.env;
+  const seat = (SEAT_IN_PATH.exec(cwd)?.[1] ?? env.COORD_ID ?? '').trim().toUpperCase();
+  if (!SEAT_ID.test(seat)) return null;
+  const seatDir = join(deps.home ?? homedir(), 'elanous-hq', 'seat-state', seat);
+  try {
+    if (!statSync(seatDir).isDirectory()) return null;
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === 'ENOENT' || code === 'ENOTDIR') return null;
+    return { seat, unread: null };
+  }
+  const msgPath = deps.msgPath ?? join(elanousStateRoot(), 'msg', 'messages.db');
+  try {
+    statSync(msgPath);
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    return { seat, unread: code === 'ENOENT' ? 0 : null };
+  }
+  // Loading MsgStore is only needed when there is an existing ledger to read.
+  // A damaged or inaccessible ledger must not prevent the TUI from booting.
+  try {
+    const msg = require('../msg/msg-store.js') as typeof import('../msg/msg-store.js');
+    const store: MsgStore = new msg.MsgStore(msgPath, { readOnly: true });
+    try {
+      return { seat, unread: store.unreadCount(seat) };
+    } finally {
+      store.close();
+    }
+  } catch {
+    return { seat, unread: null };
+  }
+}
+
+export function seatMailLine(snapshot: SeatMailSnapshot | null): string | null {
+  return snapshot ? `${snapshot.seat} · 우편 ${snapshot.unread ?? '확인 불가'}` : null;
+}

package/src/tui/slash/compact-command.ts

@@ -0,0 +1,7 @@
+/** Lightweight `/compact` command recognition for next TUI startup. */
+export const COMPACT_BUSY_STATUS = '응답 중에는 /compact 를 받지 않습니다 · 완료(또는 Esc 취소) 뒤 다시';
+export const COMPACT_NO_SESSION_STATUS = '압축할 대화가 없습니다';
+
+export function isCompactCommand(text: string): boolean {
+  return text.trim() === '/compact';
+}

package/src/tui/slash/compact.ts

@@ -0,0 +1,94 @@
+// TUI-NEXT-COMPACT — next TUI context compaction (auto before a turn · `/compact` now).
+// Wiring only: the threshold (shouldAutoCompact) and the pipeline (runCompactPipeline) run inside the
+// shared session bridge `compactSessionHistory` (src/session/compact-session.ts), the same seam the
+// continuation loop and `elanous session compact` use. Thresholds and anchor counts are the shared
+// `chat.autoCompact` defaults. The REPL child reloads the session file every turn (session/chat.ts
+// runTurn → loadSession), so rewriting the store between turns is what the next model call sees.
+import { debug } from '../../debug/log.js';
+import { compactSessionHistory } from '../../session/compact-session.js';
+import type { CompactProvider } from '../../compact/provider.js';
+import type { ChatAutoCompactConfig } from '../../user-config.js';
+export { COMPACT_BUSY_STATUS, COMPACT_NO_SESSION_STATUS, isCompactCommand } from './compact-command.js';
+
+/** Test/embedding seams. Production passes none of these. */
+export interface NextTuiCompactDeps {
+  readonly provider?: CompactProvider;
+  readonly config?: ChatAutoCompactConfig;
+  readonly modelId?: string;
+}
+
+export interface NextTuiCompactOutcome {
+  readonly fired: boolean;
+  readonly reason: string;
+  readonly before: number;
+  readonly after: number;
+  readonly ms: number;
+  /** Status-line text, or null when an auto check stays silent (under threshold). */
+  readonly status: string | null;
+}
+
+function compactStatus(before: number, after: number): string {
+  return `압축 ${before}→${after} 메시지`;
+}
+
+async function defaultConfig(): Promise<ChatAutoCompactConfig> {
+  const { getUserConfig } = await import('../../user-config.js');
+  return getUserConfig().chat.autoCompact;
+}
+
+/** Same resolution order as the continuation runner (dispatch/continuation-turn-runner.ts). */
+async function defaultModelId(): Promise<string | undefined> {
+  try {
+    const { getUserConfig } = await import('../../user-config.js');
+    const cfg = getUserConfig();
+    if (cfg.llm?.model) return cfg.llm.model;
+    const { getProviderForConfig } = await import('../../llm.js');
+    return getProviderForConfig(cfg).defaultModel;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Compact the next-TUI session once. `force:false` = the pre-turn auto check (fires only over the
+ * shared threshold); `force:true` = `/compact` (bypasses the threshold). Never throws: a failure is
+ * observed and reported as not fired, so the caller sends its turn uncompacted.
+ */
+export async function compactNextTuiSession(
+  sessionId: string,
+  input: { readonly force: boolean; readonly modelId?: string | null },
+  deps: NextTuiCompactDeps = {},
+): Promise<NextTuiCompactOutcome> {
+  const auto = !input.force;
+  const started = Date.now();
+  try {
+    const config = deps.config ?? await defaultConfig();
+    if (auto && !config.enabled) return { fired: false, reason: 'disabled', before: 0, after: 0, ms: 0, status: null };
+    const modelId = input.modelId ?? deps.modelId ?? await defaultModelId();
+    const result = await compactSessionHistory(sessionId, {
+      config,
+      force: input.force,
+      ...(modelId ? { modelId } : {}),
+      ...(deps.provider ? { provider: deps.provider } : {}),
+    });
+    const ms = Date.now() - started;
+    if (result.fired) {
+      debug.log('tui.next', 'compact', { auto, before: result.before, after: result.after, ms });
+      return { fired: true, reason: result.reason, before: result.before, after: result.after, ms, status: compactStatus(result.before, result.after) };
+    }
+    if (!auto) debug.log('tui.next', 'compact-skipped', { auto, reason: result.reason, before: result.before, ms });
+    return {
+      fired: false,
+      reason: result.reason,
+      before: result.before,
+      after: result.after,
+      ms,
+      status: auto ? null : `압축할 내용 없음 · ${result.before} 메시지`,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const ms = Date.now() - started;
+    debug.log('tui.next', 'compact-failed', { auto, ms, error: message }, { level: 'warn' });
+    return { fired: false, reason: 'error', before: 0, after: 0, ms, status: auto ? null : `압축 실패: ${message}` };
+  }
+}

package/src/tui/slash/new-session.ts

@@ -0,0 +1,35 @@
+// `/new` (alias `/session new`) — leave a session that outgrew its context without quitting next TUI.
+// The old session is never deleted; only the active marker moves.
+import { debug } from '../../debug/log.js';
+import { createSession, setActiveSessionId } from '../../session/index.js';
+
+export const NEW_SESSION_BUSY_STATUS = '응답 중에는 /new 를 받지 않습니다 · 완료(또는 Esc 취소) 뒤 다시';
+
+/** Store placeholder for an untitled session (session/index.ts createSession). */
+const UNTITLED = '(new session)';
+
+export function isNewSessionCommand(text: string): boolean {
+  const normalized = text.trim().split(/\s+/).join(' ');
+  return normalized === '/new' || normalized === '/session new';
+}
+
+export function nextTuiTitle(meta: { readonly title?: string } | null | undefined): string {
+  const title = meta?.title?.split('\n')[0]?.trim() ?? '';
+  return !title || title === UNTITLED ? '새 대화' : title;
+}
+
+export type NewTuiSessionResult =
+  | { readonly kind: 'started'; readonly id: string; readonly status: string }
+  | { readonly kind: 'rejected'; readonly status: string };
+
+export function requestNewTuiSession(input: { readonly busy: boolean; readonly from: string | null }): NewTuiSessionResult {
+  const { busy, from } = input;
+  if (busy) {
+    debug.log('tui.next', 'session-new-rejected', { from, reason: 'busy' });
+    return { kind: 'rejected', status: NEW_SESSION_BUSY_STATUS };
+  }
+  const id = createSession({ source: 'tui' }).id;
+  setActiveSessionId(id);
+  debug.log('tui.next', 'session-new', { from, to: id });
+  return { kind: 'started', id, status: `새 대화 · 이전 = ${from ? from.slice(0, 8) : '없음'}` };
+}

package/src/tui/slash/resume.ts

@@ -0,0 +1,75 @@
+// `/resume` · `/session list` · `/session load <id>` for next TUI (TUI-RESUME-PICKER · backlog #16).
+// Before this, next TUI had no handler: the words went to the model as a chat turn, so after an
+// n8n restart «/resume» started an investigation instead of showing the sessions to pick from.
+import { debug } from '../../debug/log.js';
+import { listSessions, resolveSessionId, setActiveSessionId, type SessionMeta } from '../../session/index.js';
+
+export const RESUME_BUSY_STATUS = '응답 중에는 /resume 을 받지 않습니다 · 완료(또는 Esc 취소) 뒤 다시';
+/** Rows shown by `/resume` · `/session list`. */
+export const RESUME_LIST_LIMIT = 12;
+
+export type ResumeCommand =
+  | { readonly kind: 'list' }
+  | { readonly kind: 'load'; readonly prefix: string };
+
+/** `/resume` · `/session` · `/session list|ls` → list; `/resume <id>` · `/session load|resume <id>` → load. */
+export function parseResumeCommand(text: string): ResumeCommand | null {
+  const [cmd, sub, arg, ...rest] = text.trim().split(/\s+/);
+  if (rest.length > 0) return null;
+  if (cmd === '/resume') {
+    if (arg !== undefined) return null;
+    return sub === undefined ? { kind: 'list' } : { kind: 'load', prefix: sub };
+  }
+  if (cmd === '/session' || cmd === '/sessions') {
+    if (sub === undefined || ((sub === 'list' || sub === 'ls') && arg === undefined)) return { kind: 'list' };
+    if ((sub === 'load' || sub === 'resume') && arg !== undefined) return { kind: 'load', prefix: arg };
+  }
+  return null;
+}
+
+/** Recent conversations, newest first — the rows `/resume` shows (empty scratch sessions hidden, the active one kept). */
+export function resumeCandidates(activeId: string | null, limit = RESUME_LIST_LIMIT): SessionMeta[] {
+  return listSessions({ limit, hideEmpty: true, ...(activeId ? { keepIds: [activeId] } : {}) });
+}
+
+/** One line per session: marker · 8-char id · updated · turns · title. */
+export function resumeListLines(rows: readonly SessionMeta[], activeId: string | null): string[] {
+  if (rows.length === 0) return ['저장된 대화 없음'];
+  return [
+    `최근 대화 ${rows.length}개 · /resume <id 앞자리> 로 이어 가기`,
+    ...rows.map((m) => {
+      const marker = m.id === activeId ? '▸' : ' ';
+      const when = m.updatedAt.slice(5, 16).replace('T', ' ');
+      const title = (m.title || '(제목 없음)').split('\n')[0]!.slice(0, 48);
+      return `${marker} ${m.id.slice(0, 8)}  ${when}  ${String(m.messageCount).padStart(3)}t  ${title}`;
+    }),
+  ];
+}
+
+export type ResumeTuiSessionResult =
+  | { readonly kind: 'started'; readonly id: string; readonly status: string }
+  | { readonly kind: 'rejected'; readonly status: string };
+
+/** Resolve the prefix and make that session active; rejects while a turn runs or when the prefix misses. */
+export function requestResumeTuiSession(input: { readonly busy: boolean; readonly from: string | null; readonly prefix: string }): ResumeTuiSessionResult {
+  const { busy, from, prefix } = input;
+  if (busy) {
+    debug.log('tui.next', 'session-resume-rejected', { from, prefix, reason: 'busy' });
+    return { kind: 'rejected', status: RESUME_BUSY_STATUS };
+  }
+  let id: string | null;
+  try {
+    id = resolveSessionId(prefix);
+  } catch (error) {
+    debug.log('tui.next', 'session-resume-rejected', { from, prefix, reason: 'ambiguous' });
+    return { kind: 'rejected', status: error instanceof Error ? error.message : String(error) };
+  }
+  if (!id) {
+    debug.log('tui.next', 'session-resume-rejected', { from, prefix, reason: 'not-found' });
+    return { kind: 'rejected', status: `"${prefix}" 로 시작하는 대화 없음 · /resume 으로 목록 보기` };
+  }
+  if (id === from) return { kind: 'rejected', status: `이미 이 대화다 · ${id.slice(0, 8)}` };
+  setActiveSessionId(id);
+  debug.log('tui.next', 'session-resume', { from, to: id });
+  return { kind: 'started', id, status: `대화 이어 가기 · ${id.slice(0, 8)} · 이전 = ${from ? from.slice(0, 8) : '없음'}` };
+}