aegiscode 6.1.0 → 6.2.0

package/src/export.js

@@ -0,0 +1,64 @@
+'use strict';
+
+/**
+ * Transcript → markdown/json export for /export, and the last-response
+ * extraction for /copy. Exports are written to the current directory (or the
+ * clipboard) and the resulting path is reported in the transcript.
+ *
+ * Ported from aegiscodex-dev/src/export.js (ESM → CommonJS). Output strings
+ * (the # Aegiscodex session header, the ## Claude / ## User role headers, the
+ * aegiscodex-export- filename) are kept as in the reference.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/** Render the transcript as a markdown document. */
+function transcriptToMarkdown(transcript) {
+  const lines = ['# Aegiscodex session', '', `> exported ${new Date().toISOString()}`, ''];
+  for (const m of transcript) {
+    const text = (m.text || '').replace(/\n{3,}/g, '\n\n').trim();
+    if (m.role === 'user') lines.push(`## User\n\n${text || '_(empty)_'}`, '');
+    else if (m.role === 'assistant') lines.push(`## Claude\n\n${text || '_(empty)_'}`, '');
+    else if (m.role === 'note') lines.push(`> ${text}`, '');
+  }
+  return lines.join('\n');
+}
+
+/** Render the transcript as a JSON document (array of messages). */
+function transcriptToJSON(transcript) {
+  const clean = transcript.map((m) => ({
+    role: m.role,
+    text: m.text || '',
+    ...(m.tool ? { tool: m.tool } : {}),
+  }));
+  return JSON.stringify(clean, null, 2);
+}
+
+/**
+ * Write exported text to a file. target: absolute path, 'clipboard' handled by
+ * the caller (clipboard.js) — here we only do files.
+ * Returns the absolute path written.
+ */
+function writeExportFile(text, format, cwd = process.cwd()) {
+  const ext = format === 'json' ? 'json' : 'md';
+  const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const name = `aegiscodex-export-${ts}.${ext}`;
+  const p = path.join(cwd, name);
+  fs.writeFileSync(p, text, 'utf8');
+  return p;
+}
+
+/** The most recent assistant response (last N when given a count). */
+function lastAssistantText(transcript, count = 1) {
+  const asst = transcript.filter((m) => m.role === 'assistant');
+  const n = Math.max(1, Math.min(count, asst.length));
+  return asst.slice(asst.length - n).map((m) => m.text || '').join('\n\n');
+}
+
+module.exports = {
+  transcriptToMarkdown,
+  transcriptToJSON,
+  writeExportFile,
+  lastAssistantText,
+};

package/src/history.js

@@ -0,0 +1,201 @@
+'use strict';
+
+/**
+ * Session persistence — one JSON line per exchange in ~/.aegiscode/history.jsonl
+ * (or $AEGISCODE_HOME). Keeps the file bounded (oldest entries dropped past
+ * HISTORY_LIMIT lines).
+ *
+ * Ported from aegiscodex-dev/src/history.js (ESM → CommonJS). The data dir now
+ * comes from config.js's shared `aegisDir()` helper.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { aegisDir } = require('./config.js');
+const { estimateTokens } = require('./tokens.js');
+
+const HISTORY_LIMIT = 500;
+
+function historyPath() {
+  return path.join(aegisDir(), 'history.jsonl');
+}
+
+function ensureHistoryDir() {
+  fs.mkdirSync(path.dirname(historyPath()), { recursive: true });
+}
+
+/**
+ * Record one exchange. `reply` is stored in full so /resume can restore the
+ * transcript exactly. Token accounting (Phase 4):
+ *   live — `usage` carries the real numbers from the provider stream-json
+ *          (input/output/cacheRead/cacheWrite + costUsd), stored verbatim;
+ *   demo — estimated from text length (~4 chars/token), labeled real:false.
+ * /cost aggregates these records, so compacted-away exchanges still count.
+ */
+function appendHistory({ sessionId, prompt, reply, status, usage }) {
+  try {
+    ensureHistoryDir();
+    const entry = {
+      ts: new Date().toISOString(),
+      sessionId,
+      cwd: process.cwd(),
+      prompt,
+      reply,
+      status, // 'done' | 'stopped' | 'error'
+      tokens: usage
+        ? {
+            input: usage.input || 0,
+            output: usage.output || 0,
+            cacheRead: usage.cacheRead || 0,
+            cacheWrite: usage.cacheWrite || 0,
+            real: true,
+          }
+        : { input: estimateTokens(prompt), output: estimateTokens(reply || ''), real: false },
+    };
+    if (usage && typeof usage.costUsd === 'number') entry.costUsd = usage.costUsd;
+    const p = historyPath();
+    const prev = fs.existsSync(p) ? fs.readFileSync(p, 'utf8').split('\n').filter(Boolean) : [];
+    const lines = [...prev, JSON.stringify(entry)];
+    const trimmed = lines.slice(Math.max(0, lines.length - HISTORY_LIMIT));
+    fs.writeFileSync(p, trimmed.join('\n') + '\n');
+  } catch (e) {
+    // Persistence is best-effort; never crash the session over it.
+    if (process.env.AEGIS_HIST_DEBUG) console.error('[history] write failed:', e);
+  }
+}
+
+function readEntries() {
+  try {
+    const raw = fs.readFileSync(historyPath(), 'utf8');
+    return raw
+      .split('\n')
+      .map((l) => l.trim())
+      .filter(Boolean)
+      .map((l) => { try { return JSON.parse(l); } catch { return null; } })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/** Newest-first list of own sessions, one per distinct sessionId. */
+function readOwnSessions(limit = 8) {
+  const entries = readEntries();
+  const byId = new Map();
+  for (const e of entries) {
+    if (!byId.has(e.sessionId)) byId.set(e.sessionId, e);
+  }
+  const items = [...byId.values()]
+    .sort((a, b) => (a.ts < b.ts ? 1 : -1))
+    .slice(0, limit)
+    .map((e) => ({
+      id: e.sessionId,
+      cwd: (e.cwd || '').split('/').filter(Boolean).pop() || '~',
+      summary: (e.prompt || '').slice(0, 60),
+      time: e.ts,
+      own: true,
+    }));
+  return items;
+}
+
+/** Rebuild the transcript (user/assistant pairs) of a session, oldest first. */
+function readSessionTranscript(sessionId) {
+  return readEntries()
+    .filter((e) => e.sessionId === sessionId)
+    .flatMap((e) => [
+      { role: 'user', text: e.prompt },
+      { role: 'assistant', text: e.reply || '(no response)' },
+    ]);
+}
+
+/** All history records for one session, oldest first (power /cost). */
+function sessionHistoryEntries(sessionId) {
+  return readEntries().filter((e) => e.sessionId === sessionId);
+}
+
+/**
+ * Drop every history record for a session (Phase 10b, 2.1.228 port). /clear
+ * calls this so /cost stops summing old rows — the sessionId stays stable, so
+ * rewind checkpoints and the transcript lineage are unaffected.
+ */
+function pruneSessionHistory(sessionId) {
+  try {
+    const p = historyPath();
+    if (!fs.existsSync(p)) return;
+    const kept = fs
+      .readFileSync(p, 'utf8')
+      .split('\n')
+      .map((l) => l.trim())
+      .filter(Boolean)
+      .filter((l) => {
+        try { return JSON.parse(l).sessionId !== sessionId; } catch { return true; }
+      });
+    fs.writeFileSync(p, kept.length ? kept.join('\n') + '\n' : '');
+  } catch (e) {
+    if (process.env.AEGIS_HIST_DEBUG) console.error('[history] prune failed:', e);
+  }
+}
+
+/**
+ * Sum a session's token records across history.jsonl. Compacted-away exchanges
+ * still count because /compact writes a summary exchange, it never deletes the
+ * file. `real` is true only when every record carries live CLI usage numbers.
+ */
+function aggregateSessionUsage(sessionId) {
+  const entries = sessionHistoryEntries(sessionId);
+  const usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  let real = entries.length > 0;
+  let costUsd = 0;
+  for (const e of entries) {
+    const t = e.tokens || {};
+    if (!t.real) real = false;
+    usage.input += t.input || 0;
+    usage.output += t.output || 0;
+    usage.cacheRead += t.cacheRead || 0;
+    usage.cacheWrite += t.cacheWrite || 0;
+    if (typeof e.costUsd === 'number') costUsd += e.costUsd;
+  }
+  return { entries: entries.length, usage, real, costUsd };
+}
+
+/**
+ * Sessions for the /resume overlay: own Aegiscode sessions merged with real
+ * Claude Code sessions from ~/.claude/history.jsonl, newest first.
+ */
+function readResumeList(limit = 8, ownLimit = 5, claudeLimit = 8) {
+  const items = readOwnSessions(ownLimit);
+  const claudeItems = [];
+  const histPath = `${os.homedir()}/.claude/history.jsonl`;
+  try {
+    const raw = fs.readFileSync(histPath, 'utf8');
+    const lines = raw.trim().split('\n').reverse().slice(0, claudeLimit);
+    for (const l of lines) {
+      try {
+        const j = JSON.parse(l);
+        const meta = j.extra && JSON.parse(j.extra);
+        if (meta && meta.sessionId) {
+          const c = (j.cwd || '').split('/').filter(Boolean).pop() || '~';
+          const t = (j.summary || '').slice(0, 60);
+          claudeItems.push({ id: meta.sessionId, cwd: c, summary: t, time: j.timestamp, own: false });
+        }
+      } catch {}
+    }
+  } catch {}
+  return [...items, ...claudeItems]
+    .sort((a, b) => (String(a.time || '') < String(b.time || '') ? 1 : -1))
+    .slice(0, limit);
+}
+
+module.exports = {
+  HISTORY_LIMIT,
+  historyPath,
+  ensureHistoryDir,
+  appendHistory,
+  readOwnSessions,
+  readSessionTranscript,
+  sessionHistoryEntries,
+  pruneSessionHistory,
+  aggregateSessionUsage,
+  readResumeList,
+};

package/src/init.js

@@ -0,0 +1,162 @@
+'use strict';
+
+/**
+ * /init support: sniff a project (language, build/test/lint commands, layout)
+ * and generate an AEGIS.md with real project instructions. Never overwrites an
+ * existing file — the handler reports and leaves the file alone.
+ *
+ * Ported from aegiscodex-dev/src/init.js (ESM → CommonJS). The reference wrote
+ * a CLAUDE.md; this build writes AEGIS.md and the generated document is headed
+ * "# AEGIS.md" and references "AEGIS Code". The `buildClaudeMd` export is kept
+ * as an alias of `buildAegisMd` so callers ported from the reference still
+ * resolve.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execSync } = require('node:child_process');
+
+function readJson(p, cwd) {
+  try { return JSON.parse(fs.readFileSync(path.join(cwd, p), 'utf8')); } catch { return null; }
+}
+
+function hasFile(cwd, ...names) {
+  return names.some((n) => fs.existsSync(path.join(cwd, n)));
+}
+
+function gitName(cwd) {
+  try {
+    const remote = execSync('git config --get remote.origin.url', { encoding: 'utf8', cwd, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    const base = remote.split('/').pop().replace(/\.git$/, '');
+    if (base) return base;
+  } catch {}
+  try {
+    const dir = cwd.split('/').filter(Boolean).pop();
+    return dir || 'this project';
+  } catch { return 'this project'; }
+}
+
+/** Describe a project enough to write a useful AEGIS.md. */
+function sniffProject(cwd = process.cwd()) {
+  const pkg = readJson('package.json', cwd);
+  const out = {
+    name: pkg && pkg.name ? pkg.name : gitName(cwd),
+    lang: 'unknown',
+    build: null,
+    test: null,
+    lint: null,
+    dev: null,
+    structure: [],
+    toolchain: [],
+  };
+
+  if (pkg) {
+    out.lang = 'JavaScript/TypeScript (Node.js)';
+    out.toolchain.push('Node.js');
+    const scripts = pkg.scripts || {};
+    if (scripts.build) out.build = `npm run build`;
+    if (scripts.test) out.test = `npm test`;
+    if (scripts.lint) out.lint = `npm run lint`;
+    if (scripts.dev || scripts.start || scripts.watch) out.dev = scripts.dev ? `npm run dev` : `npm start`;
+    if (pkg.packageManager) out.toolchain.push(pkg.packageManager);
+  } else if (hasFile(cwd, 'go.mod')) {
+    out.lang = 'Go';
+    out.toolchain.push('Go');
+    out.build = 'go build ./...';
+    out.test = 'go test ./...';
+    out.lint = 'golangci-lint run' ;
+    out.dev = 'go run .';
+  } else if (hasFile(cwd, 'Cargo.toml')) {
+    out.lang = 'Rust';
+    out.toolchain.push('Cargo');
+    out.build = 'cargo build';
+    out.test = 'cargo test';
+    out.lint = 'cargo clippy -- -D warnings';
+    out.dev = 'cargo run';
+  } else if (hasFile(cwd, 'pyproject.toml', 'setup.py', 'requirements.txt')) {
+    out.lang = 'Python';
+    out.toolchain.push('Python');
+    out.test = hasFile(cwd, 'pytest.ini', 'tox.ini') ? 'pytest' : 'python -m pytest';
+    out.lint = 'ruff check .';
+  } else if (hasFile(cwd, 'Makefile')) {
+    out.lang = 'C/C++ or make-driven';
+    out.toolchain.push('make');
+    out.build = 'make';
+    out.test = 'make test';
+    out.dev = 'make run';
+  } else if (hasFile(cwd, 'pom.xml', 'build.gradle')) {
+    out.lang = 'Java';
+    out.toolchain.push('Maven/Gradle');
+    out.build = hasFile(cwd, 'pom.xml') ? 'mvn package' : 'gradle build';
+    out.test = hasFile(cwd, 'pom.xml') ? 'mvn test' : 'gradle test';
+  } else if (hasFile(cwd, 'Gemfile')) {
+    out.lang = 'Ruby';
+    out.toolchain.push('Ruby');
+    out.test = 'bundle exec rspec';
+    out.build = 'bundle exec rake build';
+  } else if (hasFile(cwd, 'composer.json')) {
+    out.lang = 'PHP';
+    out.toolchain.push('Composer');
+    out.test = 'composer test';
+  } else if (hasFile(cwd, '.csproj')) {
+    out.lang = 'C#/.NET';
+    out.toolchain.push('.NET');
+    out.build = 'dotnet build';
+    out.test = 'dotnet test';
+  }
+
+  // Layout conventions.
+  for (const d of ['src', 'lib', 'app', 'tests', 'test', 'spec', 'docs', 'scripts']) {
+    if (fs.existsSync(path.join(cwd, d))) out.structure.push(d);
+  }
+  for (const f of ['eslint.config.js', '.eslintrc', '.prettierrc', 'biome.json', 'tsconfig.json', '.github/workflows']) {
+    if (fs.existsSync(path.join(cwd, f))) out.toolchain.push(f.split('/')[0]);
+  }
+
+  return out;
+}
+
+/** Render an AEGIS.md from a sniff result. */
+function buildAegisMd(sniff) {
+  const s = sniff;
+  const lines = [];
+  lines.push(`# AEGIS.md`);
+  lines.push('');
+  lines.push(`Generated by AEGIS Code /init — edit freely. This file teaches AI agents how to work in this repo.`);
+  lines.push('');
+  lines.push('## Project');
+  lines.push('');
+  lines.push(`- Project: ${s.name}`);
+  lines.push(`- Language: ${s.lang}`);
+  if (s.toolchain.length) lines.push(`- Toolchain: ${[...new Set(s.toolchain)].join(', ')}`);
+  lines.push('');
+  lines.push('## Commands');
+  lines.push('');
+  lines.push('Run these to build, test, and lint:');
+  lines.push('```bash');
+  if (s.build) lines.push(s.build + '      # build');
+  if (s.test) lines.push(s.test + '   # test');
+  if (s.lint) lines.push(s.lint + '    # lint');
+  if (s.dev) lines.push(s.dev + '       # dev server');
+  lines.push('```');
+  lines.push('');
+  if (s.structure.length) {
+    lines.push('## Project structure');
+    lines.push('');
+    for (const d of s.structure) lines.push(`- \`${d}/\` — ${d === 'src' || d === 'lib' ? 'source code' : d === 'tests' || d === 'test' || d === 'spec' ? 'tests' : d}`);
+    lines.push('');
+  }
+  lines.push('## Coding conventions');
+  lines.push('');
+  lines.push('- Keep changes minimal and focused; match the surrounding style.');
+  lines.push('- Before editing a file, read it; verify with the test command above.');
+  lines.push('- Prefer the project\'s own scripts over ad-hoc shell commands.');
+  lines.push('');
+  return lines.join('\n');
+}
+
+module.exports = {
+  sniffProject,
+  buildAegisMd,
+  buildClaudeMd: buildAegisMd, // reference name kept for compatibility
+};

package/src/input.js

@@ -0,0 +1,136 @@
+'use strict';
+
+/**
+ * Line editor with history — the input line's buffer, cursor and recall.
+ *
+ * Ported from `aegiscodex-dev/src/input.js`. The one thing worth knowing before
+ * touching it: `cursor` is a **codepoint** index, not a UTF-16 index. Slicing
+ * `buf` directly corrupts a surrogate pair the moment one has been inserted
+ * (the next insert's slice lands mid-pair and leaves a lone surrogate, which
+ * renders as U+FFFD), so every mutation splices on `[...buf]` instead.
+ */
+
+class LineEditor {
+  constructor() {
+    this.buf = '';
+    this.cursor = 0;
+    this.history = [];
+    this.hi = -1;
+    this.draft = '';
+  }
+
+  reset() {
+    this.buf = '';
+    this.cursor = 0;
+    this.hi = -1;
+    this.draft = '';
+  }
+
+  insert(ch) {
+    const arr = [...this.buf];
+    arr.splice(this.cursor, 0, ...ch);
+    this.buf = arr.join('');
+    this.cursor += [...ch].length;
+  }
+
+  left() {
+    if (this.cursor > 0) this.cursor--;
+  }
+
+  right() {
+    if (this.cursor < [...this.buf].length) this.cursor++;
+  }
+
+  home() {
+    this.cursor = 0;
+  }
+
+  end() {
+    this.cursor = [...this.buf].length;
+  }
+
+  backspace() {
+    if (this.cursor === 0) return;
+    const arr = [...this.buf];
+    arr.splice(this.cursor - 1, 1);
+    this.buf = arr.join('');
+    this.cursor--;
+  }
+
+  delete() {
+    if (this.cursor >= [...this.buf].length) return;
+    const arr = [...this.buf];
+    arr.splice(this.cursor, 1);
+    this.buf = arr.join('');
+  }
+
+  /** vim `s` — delete the char under the cursor (caller switches to insert). */
+  substChar() {
+    if (this.cursor >= [...this.buf].length) return false;
+    this.delete();
+    return true;
+  }
+
+  /** vim `S` — clear the whole line (caller switches to insert). */
+  substLine() {
+    const had = this.buf.length > 0;
+    this.buf = '';
+    this.cursor = 0;
+    return had;
+  }
+
+  killToEnd() {
+    this.buf = [...this.buf].slice(0, this.cursor).join('');
+  }
+
+  wordBack() {
+    const arr = [...this.buf];
+    let i = this.cursor;
+    while (i > 0 && arr[i - 1] === ' ') i--;
+    while (i > 0 && arr[i - 1] !== ' ') i--;
+    this.cursor = i;
+  }
+
+  wordDelete() {
+    const arr = [...this.buf];
+    let i = this.cursor;
+    while (i < arr.length && arr[i] === ' ') i++;
+    while (i < arr.length && arr[i] !== ' ') i++;
+    this.buf = arr.slice(0, this.cursor).join('') + arr.slice(i).join('');
+  }
+
+  historyUp() {
+    if (!this.history.length) return;
+    if (this.hi === -1) {
+      this.draft = this.buf;
+      this.hi = this.history.length - 1;
+    } else if (this.hi > 0) this.hi--;
+    this.buf = this.history[this.hi];
+    this.end();
+  }
+
+  historyDown() {
+    if (this.hi === -1) return;
+    if (this.hi < this.history.length - 1) {
+      this.hi++;
+      this.buf = this.history[this.hi];
+    } else {
+      this.hi = -1;
+      this.buf = this.draft;
+    }
+    this.end();
+  }
+
+  /** Commit the buffer. Returns the trimmed text and clears the line, or null
+   *  when there was nothing to submit (a bare Enter must not become a turn). */
+  submit() {
+    const text = this.buf.trim();
+    if (!text) return null;
+    this.history.push(text);
+    if (this.history.length > 500) this.history.shift();
+    this.reset();
+    return text;
+  }
+}
+
+module.exports = { LineEditor };

package/src/keys.js

@@ -0,0 +1,141 @@
+'use strict';
+
+/**
+ * Raw key decoding for the terminal (raw-mode stdin).
+ *
+ * Ported from `aegiscodex-dev/src/keys.js` so the aegiscode CLI and the
+ * reference client decode the same bytes into the same key names — the
+ * chatflow's key handling (history recall, vim motions, Esc-to-interrupt) is
+ * only correct if the decoder agrees with it.
+ *
+ * Two entry points:
+ *   decodePlain(c)      one character with no ESC prefix
+ *   decodeEscSequence(s) a complete CSI (\x1b[…X) or SS3 (\x1bOX) sequence
+ *
+ * Both return either `null` (nothing to do) or a key object `{name, ch?}`.
+ */
+
+const KEY = Object.freeze({
+  UP: 'up',
+  DOWN: 'down',
+  LEFT: 'left',
+  RIGHT: 'right',
+  ENTER: 'enter',
+  TAB: 'tab',
+  ESC: 'esc',
+  BACKSPACE: 'backspace',
+  DELETE: 'delete',
+  HOME: 'home',
+  END: 'end',
+  PAGE_UP: 'pageup',
+  PAGE_DOWN: 'pagedown',
+  CTRL_C: 'ctrl-c',
+  CTRL_D: 'ctrl-d',
+  CTRL_L: 'ctrl-l',
+  CTRL_R: 'ctrl-r',
+  CTRL_U: 'ctrl-u',
+  CTRL_A: 'ctrl-a',
+  CTRL_E: 'ctrl-e',
+  CTRL_K: 'ctrl-k',
+  CTRL_W: 'ctrl-w',
+  CTRL_T: 'ctrl-t',
+  CTRL_N: 'ctrl-n',
+  CTRL_P: 'ctrl-p',
+  CTRL_O: 'ctrl-o',
+  CTRL_LEFT: 'ctrl-left',
+  CTRL_RIGHT: 'ctrl-right',
+});
+
+/** Decode a bare character (no escape prefix) into a key object. */
+function decodePlain(chunk) {
+  switch (chunk) {
+    case '\r':
+    case '\n':
+      return { name: KEY.ENTER };
+    case '\t':
+      return { name: KEY.TAB };
+    case '\x03':
+      return { name: KEY.CTRL_C };
+    case '\x04':
+      return { name: KEY.CTRL_D };
+    case '\x0c':
+      return { name: KEY.CTRL_L };
+    case '\x12':
+      return { name: KEY.CTRL_R };
+    case '\x15':
+      return { name: KEY.CTRL_U };
+    case '\x01':
+      return { name: KEY.CTRL_A };
+    case '\x05':
+      return { name: KEY.CTRL_E };
+    case '\x0b':
+      return { name: KEY.CTRL_K };
+    case '\x17':
+      return { name: KEY.CTRL_W };
+    case '\x14':
+      return { name: KEY.CTRL_T };
+    case '\x0e':
+      return { name: KEY.CTRL_N };
+    case '\x10':
+      return { name: KEY.CTRL_P };
+    case '\x0f':
+      return { name: KEY.CTRL_O };
+    case '\x7f':
+    case '\x08':
+      return { name: KEY.BACKSPACE };
+    default: {
+      // Any other control char is meaningless here; printable is a char.
+      const code = chunk.charCodeAt(0);
+      if (code < 32 || code === 127) return { name: KEY.ESC };
+      return { name: 'char', ch: chunk };
+    }
+  }
+}
+
+/** Decode a complete CSI/SS3 escape sequence into a key object (or null). */
+function decodeEscSequence(seq) {
+  if (seq.startsWith('\x1b[')) {
+    const body = seq.slice(2);
+    // CSI with modifier params, e.g. 1;5C = ctrl+right.
+    const m = body.match(/^([0-9;]*)([A-Za-z~])$/);
+    if (m) {
+      const params = m[1] ? m[1].split(';') : [];
+      const mod = params.length > 1 ? parseInt(params[1], 10) : 0;
+      switch (m[2]) {
+        case 'A':
+          return { name: KEY.UP };
+        case 'B':
+          return { name: KEY.DOWN };
+        case 'C':
+          return mod === 5 ? { name: KEY.CTRL_RIGHT } : { name: KEY.RIGHT };
+        case 'D':
+          return mod === 5 ? { name: KEY.CTRL_LEFT } : { name: KEY.LEFT };
+        case 'H':
+          return { name: KEY.HOME };
+        case 'F':
+          return { name: KEY.END };
+        case '~': {
+          const n = parseInt(params[0] || '0', 10);
+          if (n === 3) return { name: KEY.DELETE };
+          if (n === 5) return { name: KEY.PAGE_UP };
+          if (n === 6) return { name: KEY.PAGE_DOWN };
+          if (n === 1 || n === 7) return { name: KEY.HOME };
+          if (n === 4 || n === 8) return { name: KEY.END };
+          return null;
+        }
+        default:
+          return null;
+      }
+    }
+    return null;
+  }
+  if (seq.startsWith('\x1bO')) {
+    const c = seq[2];
+    if (c === 'H') return { name: KEY.HOME };
+    if (c === 'F') return { name: KEY.END };
+    return null;
+  }
+  return { name: KEY.ESC };
+}
+
+module.exports = { KEY, decodePlain, decodeEscSequence };