@zhongqian97-code/ecode 0.2.4 → 0.2.6

package/README.md

@@ -1,25 +1,20 @@
 # ecode
 
-A minimal [Claude Code](https://claude.ai/code) clone — REPL interface with streaming LLM responses and bash tool calling.
+A minimal [Claude Code](https://claude.ai/code) clone — fullscreen TUI with streaming LLM responses, bash tool calling, Emacs keybindings, and a skill system.
 
 ## Install
 
 ```bash
-npm install -g @zhongqian-code/ecode
+npm install -g @zhongqian97-code/ecode
 ```
 
-## Usage
+## Quick start
 
 ```bash
-# Set your API key (OpenAI-compatible endpoint)
 export ECODE_API_KEY=sk-...
-
-# Start the REPL
 ecode
 ```
 
-Type your message, press Enter. Type `exit` to quit.
-
 ## Configuration
 
 Priority: **env vars > config file > defaults**
@@ -31,19 +26,33 @@ Priority: **env vars > config file > defaults**
 | `ECODE_API_KEY` | *(required)* | API key |
 | `ECODE_BASE_URL` | `https://api.openai.com/v1` | Base URL (any OpenAI-compatible endpoint) |
 | `ECODE_MODEL` | `gpt-4o` | Model name |
+| `ECODE_LOG_DIR` | *(disabled)* | Directory for session logs (JSONL) |
 
 ### Config file
 
-`~/.ecode/config.json`
+`~/.ecode/config.json` — all fields are optional, only set what you need.
 
 ```json
 {
   "apiKey": "sk-...",
   "baseUrl": "https://api.openai.com/v1",
-  "model": "gpt-4o"
+  "model": "gpt-4o",
+  "logDir": "~/.ecode/logs",
+  "contextLimit": 128000,
+  "dangerousPatterns": [
+    "rm -rf", "sudo", "chmod", "chown",
+    "mkfs", "dd", "fdisk",
+    "kill", "pkill", "killall",
+    "reboot", "shutdown", "halt",
+    "curl -X DELETE", "wget --delete-after"
+  ]
 }
 ```
 
+**`contextLimit`** — override automatic context window detection (tokens). Useful for unlisted or self-hosted models.
+
+**`dangerousPatterns`** — list of command prefixes that require double confirmation. Setting this field replaces the entire default list.
+
 ### Using with other providers
 
 ```bash
@@ -53,6 +62,12 @@ export ECODE_API_KEY=sk-...
 export ECODE_MODEL=deepseek-chat
 ecode
 
+# Anthropic Claude (via proxy or compatible gateway)
+export ECODE_BASE_URL=https://your-openai-proxy/v1
+export ECODE_API_KEY=sk-ant-...
+export ECODE_MODEL=claude-sonnet-4-6
+ecode
+
 # Local Ollama
 export ECODE_BASE_URL=http://localhost:11434/v1
 export ECODE_API_KEY=ollama
@@ -60,15 +75,93 @@ export ECODE_MODEL=llama3
 ecode
 ```
 
+Context window sizes are pre-configured for common models (GPT-4o, Claude, DeepSeek, o1/o3). Unknown models default to 128K.
+
+## Keyboard shortcuts
+
+### Submitting and navigation
+
+| Key | Action |
+|---|---|
+| `Enter` | Submit message |
+| `Shift+Enter` | Insert newline (multi-line input) |
+| `Tab` | Toggle tool call / thinking expansion |
+| `PageUp` / `PageDown` | Scroll conversation history |
+| `Ctrl+V` | Scroll down (same as PageDown) |
+| `Alt+V` | Scroll up (same as PageUp) |
+| `Ctrl+P` | Previous command (input history) |
+| `Ctrl+N` | Next command (input history) |
+
+### Emacs cursor movement
+
+| Key | Action |
+|---|---|
+| `Ctrl+A` | Jump to start of line |
+| `Ctrl+E` | Jump to end of line |
+| `Ctrl+B` / `←` | Move left one character |
+| `Ctrl+F` / `→` | Move right one character |
+| `Alt+B` | Move left one word |
+| `Alt+F` | Move right one word |
+
+### Emacs editing
+
+| Key | Action |
+|---|---|
+| `Backspace` | Delete character before cursor |
+| `Ctrl+D` | Delete character at cursor |
+| `Ctrl+K` | Kill from cursor to end of line |
+| `Ctrl+U` | Kill from start of line to cursor |
+| `Ctrl+W` | Kill word backward |
+
 ## Bash tool calling
 
 ecode gives the LLM access to a bash tool. Commands are classified into three tiers:
 
 | Tier | Examples | Behavior |
 |---|---|---|
-| **Allow** | `ls`, `cat`, `pwd`, `echo` | Auto-execute, no prompt |
-| **Normal** | `git status`, `npm install` | Single confirmation |
-| **Danger** | `rm -rf`, `sudo`, `chmod` | Double confirmation |
+| **Allow** | `ls`, `cat`, `pwd`, `echo`, `head`, `tail`, `wc`, `date`, `whoami`, `which`, `env` | Auto-execute, no prompt |
+| **Normal** | `git status`, `npm install`, `grep` | Single confirmation |
+| **Danger** | `rm -rf`, `sudo`, `chmod`, `kill`, `reboot` | Double confirmation |
+
+The danger list is fully customizable via `dangerousPatterns` in the config file.
+
+## Skills (slash commands)
+
+Type `/` to see available skills with Tab autocomplete. Skills inject structured instructions into the LLM context.
+
+| Skill | Description |
+|---|---|
+| `/plan` | Restate requirements and create a step-by-step implementation plan |
+| `/tdd` | Test-driven development with red-green-refactor loop |
+| `/diagnose` | Disciplined debug loop: reproduce → minimise → hypothesise → instrument → fix |
+| `/grill-me` | Relentless interview to stress-test a plan or design |
+| `/grill-with-docs` | Grilling session that challenges plans against the project's domain model |
+| `/improve-codebase-architecture` | Find deepening opportunities and architectural friction |
+| `/security-review` | Security vulnerability scan of pending changes |
+| `/search-first` | Research-before-coding workflow |
+| `/zoom-out` | Get a higher-level map of the relevant modules and callers |
+| `/to-prd` | Turn current context into a PRD |
+| `/to-issues` | Break a plan into independently-grabbable issues |
+| `/triage` | Move issues through a triage state machine |
+| `/write-a-skill` | Create new agent skills |
+| `/caveman` | Ultra-compressed mode (~75% token reduction) |
+
+Run `/setup-matt-pocock-skills` once to configure the issue tracker and triage vocabulary for your repo.
+
+## Session logging
+
+Enable JSONL session logs to replay or analyze conversations:
+
+```bash
+# via env var
+export ECODE_LOG_DIR=~/.ecode/logs
+ecode
+
+# via config file
+# "logDir": "~/.ecode/logs"
+```
+
+Each session writes a timestamped `.jsonl` file. Each line is a JSON object with `role`, `content`, and `timestamp`.
 
 ## Requirements
 

package/dist/index.js

@@ -96,7 +96,7 @@ function loadConfig() {
 
 // src/ui/App.tsx
 import { useState as useState3, useCallback, useRef as useRef2, useEffect as useEffect3, useMemo } from "react";
-import { Box as Box5, useInput as useInput2, useStdout } from "ink";
+import { Box as Box5, useInput as useInput2, useStdout, useStdin } from "ink";
 
 // src/llm.ts
 import OpenAI from "openai";
@@ -597,19 +597,45 @@ import { Box as Box3, Text as Text3, useInput } from "ink";
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 var CURSOR_CHAR = "\u258C";
 var BLINK_INTERVAL_MS = 530;
+function wordBackward(s, pos) {
+  let i = pos;
+  while (i > 0 && s[i - 1] === " ") {
+    i--;
+  }
+  while (i > 0 && s[i - 1] !== " ") {
+    i--;
+  }
+  return i;
+}
+function wordForward(s, pos) {
+  let i = pos;
+  const len = s.length;
+  while (i < len && s[i] !== " ") {
+    i++;
+  }
+  while (i < len && s[i] === " ") {
+    i++;
+  }
+  return i;
+}
 var Input = forwardRef(function Input2({ isActive, onSubmit, onChange, placeholder }, ref) {
-  const [lines, setLines] = useState2([""]);
+  const [value, setValue] = useState2("");
+  const [cursorPos, setCursorPos] = useState2(0);
   const [cursorVisible, setCursorVisible] = useState2(true);
-  const linesRef = useRef(lines);
-  linesRef.current = lines;
+  const valueRef = useRef(value);
+  valueRef.current = value;
+  const cursorPosRef = useRef(cursorPos);
+  cursorPosRef.current = cursorPos;
   const onChangeRef = useRef(onChange);
   onChangeRef.current = onChange;
   const onSubmitRef = useRef(onSubmit);
   onSubmitRef.current = onSubmit;
   useImperativeHandle(ref, () => ({
     fill(text) {
-      const newLines = text ? text.split("\n") : [""];
-      setLines(newLines);
+      valueRef.current = text;
+      cursorPosRef.current = text.length;
+      setValue(text);
+      setCursorPos(text.length);
       onChangeRef.current?.(text);
     }
   }));
@@ -625,49 +651,124 @@ var Input = forwardRef(function Input2({ isActive, onSubmit, onChange, placehold
       clearInterval(timer);
     };
   }, [isActive]);
+  function setValueSync(newValue) {
+    valueRef.current = newValue;
+    setValue(newValue);
+  }
+  function setCursorPosSync(newPos) {
+    cursorPosRef.current = newPos;
+    setCursorPos(newPos);
+  }
   useInput(
     (input, key) => {
-      const currentLines = linesRef.current;
+      const v = valueRef.current;
+      const pos = cursorPosRef.current;
       if (key.return && key.shift) {
-        const newLines = [...currentLines, ""];
-        setLines(newLines);
-        onChangeRef.current?.(newLines.join("\n"));
+        const newValue = v.slice(0, pos) + "\n" + v.slice(pos);
+        setValueSync(newValue);
+        setCursorPosSync(pos + 1);
+        onChangeRef.current?.(newValue);
         return;
       }
       if (key.return) {
-        const text = currentLines.join("\n");
-        onSubmitRef.current(text);
-        setLines([""]);
+        onSubmitRef.current(v);
+        setValueSync("");
+        setCursorPosSync(0);
         onChangeRef.current?.("");
         return;
       }
       if (key.backspace || key.delete) {
-        const lastIdx = currentLines.length - 1;
-        const lastLine = currentLines[lastIdx];
-        let newLines;
-        if (lastLine.length > 0) {
-          newLines = [...currentLines.slice(0, lastIdx), lastLine.slice(0, -1)];
-        } else if (currentLines.length > 1) {
-          newLines = currentLines.slice(0, -1);
-        } else {
+        if (pos === 0) return;
+        const newValue = v.slice(0, pos - 1) + v.slice(pos);
+        setValueSync(newValue);
+        setCursorPosSync(pos - 1);
+        onChangeRef.current?.(newValue);
+        return;
+      }
+      if (key.ctrl) {
+        switch (input) {
+          case "a": {
+            setCursorPosSync(0);
+            return;
+          }
+          case "e": {
+            setCursorPosSync(v.length);
+            return;
+          }
+          case "b": {
+            setCursorPosSync(Math.max(0, pos - 1));
+            return;
+          }
+          case "f": {
+            setCursorPosSync(Math.min(v.length, pos + 1));
+            return;
+          }
+          case "k": {
+            const nextNl = v.indexOf("\n", pos);
+            const lineEnd = nextNl === -1 ? v.length : nextNl;
+            const newValue = v.slice(0, pos) + v.slice(lineEnd);
+            setValueSync(newValue);
+            onChangeRef.current?.(newValue);
+            return;
+          }
+          case "u": {
+            const newValue = v.slice(pos);
+            setValueSync(newValue);
+            setCursorPosSync(0);
+            onChangeRef.current?.(newValue);
+            return;
+          }
+          case "w": {
+            const newPos = wordBackward(v, pos);
+            const newValue = v.slice(0, newPos) + v.slice(pos);
+            setValueSync(newValue);
+            setCursorPosSync(newPos);
+            onChangeRef.current?.(newValue);
+            return;
+          }
+          case "d": {
+            if (pos >= v.length) return;
+            const newValue = v.slice(0, pos) + v.slice(pos + 1);
+            setValueSync(newValue);
+            onChangeRef.current?.(newValue);
+            return;
+          }
+          default:
+            return;
+        }
+      }
+      if (key.meta) {
+        if (input === "b") {
+          setCursorPosSync(wordBackward(v, pos));
           return;
         }
-        setLines(newLines);
-        onChangeRef.current?.(newLines.join("\n"));
+        if (input === "f") {
+          setCursorPosSync(wordForward(v, pos));
+          return;
+        }
+        return;
+      }
+      if (key.leftArrow) {
+        setCursorPosSync(Math.max(0, pos - 1));
+        return;
+      }
+      if (key.rightArrow) {
+        setCursorPosSync(Math.min(v.length, pos + 1));
         return;
       }
-      if (key.ctrl || key.escape || key.upArrow || key.downArrow || key.leftArrow || key.rightArrow || key.tab || key.pageUp || key.pageDown) {
+      if (key.escape || key.upArrow || key.downArrow || key.tab || key.pageUp || key.pageDown) {
         return;
       }
       if (input.length > 0) {
-        const newLines = [...currentLines.slice(0, -1), currentLines[currentLines.length - 1] + input];
-        setLines(newLines);
-        onChangeRef.current?.(newLines.join("\n"));
+        const newValue = v.slice(0, pos) + input + v.slice(pos);
+        setValueSync(newValue);
+        setCursorPosSync(pos + input.length);
+        onChangeRef.current?.(newValue);
       }
     },
     { isActive }
   );
-  const isEmpty = lines.every((line) => line === "");
+  const isEmpty = value === "";
   const renderLines = () => {
     if (isEmpty && placeholder) {
       return /* @__PURE__ */ jsxs3(Box3, { children: [
@@ -676,19 +777,41 @@ var Input = forwardRef(function Input2({ isActive, onSubmit, onChange, placehold
         isActive && cursorVisible && /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: CURSOR_CHAR })
       ] });
     }
+    const lines = value.split("\n");
+    let remaining = cursorPos;
+    let cursorLine = 0;
+    let cursorCol = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const lineLen = lines[i].length;
+      if (remaining <= lineLen) {
+        cursorLine = i;
+        cursorCol = remaining;
+        break;
+      }
+      remaining -= lineLen + 1;
+    }
     return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: lines.map((line, idx) => {
-      const isLastLine = idx === lines.length - 1;
       const prefix = idx === 0 ? "> " : "  ";
+      const showCursor = isActive && cursorVisible && idx === cursorLine;
+      if (!showCursor) {
+        return /* @__PURE__ */ jsxs3(Box3, { children: [
+          /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: prefix }),
+          /* @__PURE__ */ jsx3(Text3, { children: line })
+        ] }, idx);
+      }
+      const before = line.slice(0, cursorCol);
+      const after = line.slice(cursorCol);
       return /* @__PURE__ */ jsxs3(Box3, { children: [
         /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: prefix }),
-        /* @__PURE__ */ jsx3(Text3, { children: line }),
-        isActive && isLastLine && cursorVisible && /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: CURSOR_CHAR })
+        /* @__PURE__ */ jsx3(Text3, { children: before }),
+        /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: CURSOR_CHAR }),
+        /* @__PURE__ */ jsx3(Text3, { children: after })
       ] }, idx);
     }) });
   };
   return /* @__PURE__ */ jsx3(Box3, { children: isActive ? renderLines() : /* @__PURE__ */ jsxs3(Box3, { children: [
     /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "> " }),
-    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: isEmpty ? placeholder ?? "" : lines.join(" ") })
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: isEmpty ? placeholder ?? "" : value })
   ] }) });
 });
 var Input_default = Input;
@@ -747,10 +870,32 @@ function dismiss(state) {
   return { ...state, dismissed: true };
 }
 
+// src/ui/mouseInput.ts
+var SGR_MOUSE_RE = /^\x1b\[<(\d+);\d+;\d+[Mm]/;
+function parseMouseScroll(data) {
+  const s = typeof data === "string" ? data : data.toString("binary");
+  if (!s) return null;
+  const sgrMatch = SGR_MOUSE_RE.exec(s);
+  if (sgrMatch) {
+    const cb = parseInt(sgrMatch[1], 10);
+    if (cb === 64) return { direction: "up" };
+    if (cb === 65) return { direction: "down" };
+    return null;
+  }
+  if (s.length >= 6 && s.charCodeAt(0) === 27 && s[1] === "[" && s[2] === "M") {
+    const buttonByte = s.charCodeAt(3);
+    if (buttonByte === 96) return { direction: "up" };
+    if (buttonByte === 97) return { direction: "down" };
+    return null;
+  }
+  return null;
+}
+
 // src/ui/App.tsx
 import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 function App({ config: config2, version: version2, autoMode: autoMode2 = false, registry: registry2, llmClient }) {
   const { stdout } = useStdout();
+  const { stdin } = useStdin();
   const historyMaxHeight = Math.max(5, (stdout?.rows ?? 24) - 4);
   const [messages, setMessages] = useState3([]);
   const [status, setStatus] = useState3("idle");
@@ -764,6 +909,11 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
   const [confirmPrompt, setConfirmPrompt] = useState3(void 0);
   const [expandTools, setExpandTools] = useState3(false);
   const [scrollOffset, setScrollOffset] = useState3(0);
+  const [inputHistory, setInputHistory] = useState3([]);
+  const inputHistoryRef = useRef2([]);
+  inputHistoryRef.current = inputHistory;
+  const historyIndexRef = useRef2(-1);
+  const isNavigatingHistoryRef = useRef2(false);
   const totalLines = useMemo(() => {
     const visible = messages.filter((m) => m.role !== "system");
     return visible.reduce(
@@ -771,6 +921,8 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
       0
     );
   }, [messages, expandTools, stdout?.columns]);
+  const totalLinesRef = useRef2(totalLines);
+  totalLinesRef.current = totalLines;
   const pendingConfirmRef = useRef2(null);
   const llmRef = useRef2(llmClient ?? createLLMClient(config2));
   const inputRef = useRef2(null);
@@ -799,7 +951,25 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
     }
     loggedCountRef.current = messages.length;
   }, [messages]);
-  useInput2((_input, key) => {
+  useEffect3(() => {
+    if (!stdin || !stdout) return;
+    stdout.write("\x1B[?1000h\x1B[?1006h");
+    const onMouseData = (data) => {
+      const event = parseMouseScroll(data);
+      if (!event) return;
+      if (event.direction === "up") {
+        setScrollOffset((prev) => Math.min(prev + 3, Math.max(0, totalLinesRef.current - 1)));
+      } else {
+        setScrollOffset((prev) => Math.max(0, prev - 3));
+      }
+    };
+    stdin.on("data", onMouseData);
+    return () => {
+      stdout.write("\x1B[?1000l\x1B[?1006l");
+      stdin.off("data", onMouseData);
+    };
+  }, [stdin, stdout]);
+  useInput2((input, key) => {
     const skillList = registry2?.list() ?? [];
     const suggestions = computeSuggestions(skillList, acState);
     const open = isOpen(acState, suggestions);
@@ -837,6 +1007,38 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
       setScrollOffset((prev) => Math.max(0, prev - scrollStep));
       return;
     }
+    if (key.ctrl && input === "v") {
+      setScrollOffset((prev) => Math.max(0, prev - scrollStep));
+      return;
+    }
+    if (key.meta && input === "v") {
+      setScrollOffset((prev) => Math.min(prev + scrollStep, Math.max(0, totalLines - 1)));
+      return;
+    }
+    if (key.ctrl && input === "p") {
+      const history = inputHistoryRef.current;
+      const newIndex = Math.min(historyIndexRef.current + 1, history.length - 1);
+      if (newIndex >= 0 && newIndex < history.length) {
+        historyIndexRef.current = newIndex;
+        isNavigatingHistoryRef.current = true;
+        inputRef.current?.fill(history[newIndex]);
+      }
+      return;
+    }
+    if (key.ctrl && input === "n") {
+      const history = inputHistoryRef.current;
+      if (historyIndexRef.current > 0) {
+        const newIndex = historyIndexRef.current - 1;
+        historyIndexRef.current = newIndex;
+        isNavigatingHistoryRef.current = true;
+        inputRef.current?.fill(history[newIndex]);
+      } else if (historyIndexRef.current === 0) {
+        historyIndexRef.current = -1;
+        isNavigatingHistoryRef.current = true;
+        inputRef.current?.fill("");
+      }
+      return;
+    }
   });
   const confirm = useCallback((prompt) => {
     return new Promise((resolve2) => {
@@ -980,6 +1182,8 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
         return;
       }
       if (!trimmed) return;
+      setInputHistory((prev) => [trimmed, ...prev.slice(0, 99)]);
+      historyIndexRef.current = -1;
       setScrollOffset(0);
       if (registry2) {
         const skillResult = handleSkillInput(trimmed, registry2);
@@ -1021,6 +1225,11 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
   );
   const isInputActive = status === "idle" || status === "awaiting_confirm";
   const handleInputTextChange = useCallback((text) => {
+    if (isNavigatingHistoryRef.current) {
+      isNavigatingHistoryRef.current = false;
+    } else {
+      historyIndexRef.current = -1;
+    }
     if (status !== "awaiting_confirm") {
       setAcState((prev) => handleInputChange(prev, text));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhongqian97-code/ecode",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "A minimal Claude Code clone with REPL interface and bash tool calling",
   "type": "module",
   "author": "zhongqian97-code",