chainlesschain 0.162.49 → 0.162.61

package/src/index.js

@@ -67,6 +67,7 @@ import { registerLoopCommand } from "./commands/loop.js";
 import { registerPermissionsCommand } from "./commands/permissions.js";
 import { registerOutputStyleCommand } from "./commands/output-style.js";
 import { registerStatuslineCommand } from "./commands/statusline.js";
+import { registerTerminalSetupCommand } from "./commands/terminal-setup.js";
 import { registerIdeCommand } from "./commands/ide.js";
 import { registerConsolCommand } from "./commands/consol.js";
 import { registerImportCommand } from "./commands/import.js";
@@ -479,6 +480,7 @@ export function createProgram(opts = {}) {
   registerPermissionsCommand(program);
   registerOutputStyleCommand(program);
   registerStatuslineCommand(program);
+  registerTerminalSetupCommand(program);
   registerIdeCommand(program);
   registerConsolCommand(program);
 

package/src/lib/image-input.js

@@ -115,8 +115,14 @@ export function imageUrlBlockToAnthropic(block) {
   };
 }
 
-/** Default vision model (Volcengine Ark Doubao-Seed-1.6 Vision) when none configured. */
-export const DEFAULT_VISION_MODEL = "doubao-seed-1-6-vision-250815";
+/**
+ * Default vision model when none is configured — Volcengine Ark
+ * Doubao-Seed-2.0-lite (id `doubao-seed-2-0-lite-260215`, dated YYMMDD =
+ * 2026-02-15), a natively multimodal model (text/image/video; 2.0 has no
+ * separate "-vision-" SKU). Override via --vision-model or config.llm.visionModel
+ * to pin a different snapshot.
+ */
+export const DEFAULT_VISION_MODEL = "doubao-seed-2-0-lite-260215";
 
 /**
  * Resolve the effective LLM config for a run. When an image is attached, default

package/src/lib/llm-pricing.js

@@ -35,6 +35,15 @@ export const PRICE_TABLE = Object.freeze({
     { match: "haiku", in: 1, out: 5 },
   ],
   openai: [
+    // GPT-5 family (2026). Matching is longest-pattern-first, so dated/variant
+    // ids (gpt-5.5, gpt-5.5-pro, gpt-5.5-instant, …) resolve to the most
+    // specific rate; bare "gpt-5" is the catch-all base rate.
+    { match: "gpt-5.5-pro", in: 30, out: 180 },
+    { match: "gpt-5.5", in: 5, out: 30 },
+    { match: "gpt-5.4", in: 2.5, out: 15 },
+    { match: "gpt-5-mini", in: 0.25, out: 2 },
+    { match: "gpt-5-nano", in: 0.05, out: 0.4 },
+    { match: "gpt-5", in: 1.25, out: 10 },
     { match: "gpt-4o-mini", in: 0.15, out: 0.6 },
     { match: "gpt-4o", in: 2.5, out: 10 },
     { match: "gpt-4-turbo", in: 10, out: 30 },
@@ -49,6 +58,12 @@ export const PRICE_TABLE = Object.freeze({
   ],
   // Volcengine Doubao — rough USD conversion of public RMB list pricing.
   volcengine: [
+    // Doubao Seed 2.0 family (2026, e.g. doubao-seed-2-0-lite-260215) is
+    // natively multimodal. Rates ≈ official CNY ÷ ~7.2 (lite ≤32k is 0.6/3.6
+    // CNY → $0.08/$0.50); the generic "seed" rate below underprices 2.0 output.
+    { match: "seed-2-0-pro", in: 0.5, out: 2.5 },
+    { match: "seed-2-0-lite", in: 0.08, out: 0.5 },
+    { match: "seed-2-0-mini", in: 0.03, out: 0.3 },
     { match: "seed-1-6", in: 0.11, out: 0.28 },
     { match: "seed", in: 0.11, out: 0.28 },
     { match: "pro", in: 0.11, out: 0.28 },

package/src/lib/permission-rules.cjs

@@ -14,6 +14,8 @@
  *   Edit(//etc/**)        → edit_file on an absolute path under /etc
  *   WebFetch(domain:example.com) → web_fetch of https://example.com/…
  *   Bash                  → every run_shell call
+ *   *                     → every tool call (Claude-Code deny-all idiom)
+ *   Bash(*)               → every run_shell call (lone-`*` pattern = match-all)
  *
  * Pure + self-contained (no glob dependency — `globToRegExp` is built in, the
  * repo avoids pulling minimatch/picomatch). Decision precedence is
@@ -75,6 +77,8 @@ const URL_TOOLS = new Set(["web_fetch"]);
 function toolMatches(ruleTool, actualTool) {
   const r = String(ruleTool || "").toLowerCase();
   const a = String(actualTool || "");
+  // Claude-Code `*` deny-all: a bare-`*` tool token matches every tool.
+  if (r === "*") return true;
   if (Object.prototype.hasOwnProperty.call(TOOL_GROUPS, r)) {
     return TOOL_GROUPS[r].includes(a);
   }
@@ -88,7 +92,8 @@ function toolMatches(ruleTool, actualTool) {
 function parseRule(rule) {
   const raw = String(rule || "").trim();
   if (!raw) return null;
-  const m = raw.match(/^([A-Za-z_][\w-]*)\s*(?:\(([\s\S]*)\))?$/);
+  // Tool token is an umbrella/CLI name OR a bare `*` (Claude-Code deny-all).
+  const m = raw.match(/^(\*|[A-Za-z_][\w-]*)\s*(?:\(([\s\S]*)\))?$/);
   if (!m) return null;
   const tool = m[1];
   const pattern = m[2] === undefined ? null : m[2].trim();
@@ -198,6 +203,11 @@ function matchUrl(pattern, url) {
  */
 function matchPattern(pattern, actualTool, args, cwd) {
   if (pattern === null) return true;
+  // A lone `*` / `**` pattern matches any target regardless of slashes — covers
+  // `Bash(*)`, `Read(**)`, `WebFetch(*)`, etc. Done before the glob path so a
+  // command/url/path containing `/` can't slip past a deny-all (globToRegExp's
+  // `*` → `[^/]*` otherwise excludes slashes).
+  if (pattern === "*" || pattern === "**") return true;
   const target = extractTarget(actualTool, args, cwd);
   if (target.kind === "command") {
     return target.value ? matchCommand(pattern, target.value) : false;

package/src/lib/personal-data-hub-wiring.js

@@ -54,6 +54,9 @@ const {
   LocalFilesAdapter,
   BilibiliAdapter,
   WeiboAdapter,
+  ZhihuAdapter,
+  BossZhipinAdapter,
+  CsdnAdapter,
   DouyinAdapter,
   XiaohongshuAdapter,
   ToutiaoAdapter,
@@ -68,7 +71,13 @@ const {
   QQPcAdapter,
   AppleHealthAdapter,
   NeteaseMusicAdapter,
+  KugouMusicAdapter,
+  IqiyiVideoAdapter,
+  TencentVideoAdapter,
   WeReadAdapter,
+  WpsDocAdapter,
+  TencentDocsAdapter,
+  BaiduNetdiskAdapter,
   DingTalkPcAdapter,
   FeishuPcAdapter,
   BaiduMapAdapter,
@@ -76,9 +85,12 @@ const {
   JdAdapter,
   MeituanAdapter,
   PinduoduoAdapter,
+  DianpingAdapter,
   Train12306Adapter,
   TaobaoAdapter,
   CtripAdapter,
+  TongchengAdapter,
+  DidiAdapter,
   AmapAdapter,
   TelegramAdapter,
   WhatsAppAdapter,
@@ -514,6 +526,9 @@ async function initHub() {
   // accurate.
   for (const Cls of [
     WeiboAdapter,
+    ZhihuAdapter,
+    BossZhipinAdapter,
+    CsdnAdapter,
     DouyinAdapter,
     XiaohongshuAdapter,
     ToutiaoAdapter,
@@ -528,7 +543,13 @@ async function initHub() {
     QQPcAdapter,
     AppleHealthAdapter,
     NeteaseMusicAdapter,
+    KugouMusicAdapter,
+    IqiyiVideoAdapter,
+    TencentVideoAdapter,
     WeReadAdapter,
+    WpsDocAdapter,
+    TencentDocsAdapter,
+    BaiduNetdiskAdapter,
     DingTalkPcAdapter,
     FeishuPcAdapter,
     BaiduMapAdapter,
@@ -536,9 +557,12 @@ async function initHub() {
     JdAdapter,
     MeituanAdapter,
     PinduoduoAdapter,
+    DianpingAdapter,
     Train12306Adapter,
     TaobaoAdapter,
     CtripAdapter,
+    TongchengAdapter,
+    DidiAdapter,
     AmapAdapter,
     TelegramAdapter,
     WhatsAppAdapter,

package/src/lib/repl-multiline.js

@@ -0,0 +1,64 @@
+/**
+ * Multiline REPL input via backslash continuation (Claude-Code multiline parity).
+ *
+ * Node's readline submits on every Enter, so a single prompt is one line. This
+ * pure helper lets the REPL accumulate a multi-line prompt: a physical line that
+ * ends with a continuation backslash keeps the prompt open and the next line is
+ * appended (joined with "\n"), so code blocks / multi-paragraph prompts can be
+ * entered without a turn firing per line.
+ *
+ * The rule is shell-like but Windows-path-safe: a trailing backslash continues
+ * the line ONLY when it is a lone `\` or the backslash run is preceded by
+ * whitespace, and the run length is odd (so `\\` stays a literal backslash).
+ * That keeps a stray path like `dir C:\` from being swallowed as a continuation.
+ *
+ *   analyzeContinuation("write a function \\") → { continued:true,  text:"write a function" }
+ *   analyzeContinuation("dir C:\\")            → { continued:false, text:"dir C:\\" }
+ *   analyzeContinuation("plain line")          → { continued:false, text:"plain line" }
+ *
+ * The REPL keeps an array of `text` pieces and `joinContinuation()` stitches the
+ * final submission.
+ */
+
+/** Count the run of backslashes at the very end of a string. */
+function trailingBackslashes(s) {
+  let n = 0;
+  for (let i = s.length - 1; i >= 0 && s[i] === "\\"; i--) n++;
+  return n;
+}
+
+/**
+ * Decide whether a physical input line continues onto the next one.
+ *
+ * @param {string} line  the raw line as readline delivered it
+ * @returns {{ continued:boolean, text:string }}
+ *   continued → drop the trailing backslash (+ the space before it) and wait for
+ *   more; not continued → the line stands as typed (text === line).
+ */
+export function analyzeContinuation(line) {
+  const s = typeof line === "string" ? line : "";
+  const n = trailingBackslashes(s);
+  if (n === 0 || n % 2 === 0) return { continued: false, text: s };
+  // Odd trailing backslashes: gate on what precedes the run so Windows paths
+  // (no preceding whitespace) are not treated as continuations.
+  const before = s[s.length - n - 1]; // undefined when the run is the whole line
+  const gated = before === undefined || /\s/.test(before);
+  if (!gated) return { continued: false, text: s };
+  // Strip exactly one trailing backslash, then trim the now-trailing whitespace
+  // so the join reads cleanly.
+  const text = s.slice(0, s.length - 1).replace(/\s+$/, "");
+  return { continued: true, text };
+}
+
+/**
+ * Stitch accumulated continuation pieces plus the final line into one prompt.
+ *
+ * @param {string[]} pieces  prior `text` values from continued lines
+ * @param {string} finalLine the line that ended the continuation (raw)
+ * @returns {string}
+ */
+export function joinContinuation(pieces, finalLine) {
+  const parts = Array.isArray(pieces) ? pieces.slice() : [];
+  parts.push(typeof finalLine === "string" ? finalLine : "");
+  return parts.join("\n");
+}

package/src/lib/repl-rewind.js

@@ -1,6 +1,8 @@
 /**
- * REPL conversation rewind — Claude-Code double-Esc parity (v1: conversation
- * state; file state stays on `cc checkpoint restore`, hinted alongside).
+ * REPL conversation rewind — Claude-Code double-Esc parity. Conversation state
+ * AND, when auto-checkpointing is on (git work tree), the file tree are rewound
+ * together — matching Claude Code's rewind, which restores code + conversation
+ * in one step instead of leaving files on a separate `cc checkpoint restore`.
  *
  * Pure helpers over the REPL's live `messages` array so the picker logic is
  * unit-testable without readline:
@@ -8,9 +10,19 @@
  *  - rewindToTurn(): truncate the conversation BACK TO BEFORE turn #n and
  *    return the original text so the caller can prefill the input line
  *    (edit-and-resend, like Claude Code's rewind).
+ *  - pickCheckpointForTurn(): map a rewound turn to the file checkpoint that
+ *    captured the work tree just before that turn first mutated it.
+ *  - pruneMarksAfter(): drop checkpoint marks for the turns that were dropped.
  *
  * Trigger surfaces (wired in agent-repl): `/rewind` lists, `/rewind <n>`
  * rewinds, and a double-Esc while idle prints the same list as a shortcut.
+ *
+ * Checkpoint marks: the REPL records `{ atMessageCount, id, tool }` for every
+ * `checkpoint` event the agent loop emits — `atMessageCount` is `messages.length`
+ * at the instant the snapshot was taken (always just AFTER the turn's user
+ * message was appended, so it is strictly greater than that turn's message
+ * index, and not-greater than any later turn's). That ordering is what lets a
+ * turn be matched to its pre-mutation snapshot purely from the count.
  */
 
 export const DEFAULT_LIST_LIMIT = 10;
@@ -64,10 +76,61 @@ export function rewindToTurn(messages, n) {
   messages.splice(turn.index);
   return {
     removed,
+    index: turn.index,
     text: typeof turn.content === "string" ? turn.content : null,
   };
 }
 
+/**
+ * Map a rewound turn to the checkpoint that captured the work tree right BEFORE
+ * that turn first changed a file.
+ *
+ * A turn's auto-checkpoints are all taken with `atMessageCount` strictly greater
+ * than the turn's message index (the user message is appended first), while the
+ * previous turn's checkpoints have `atMessageCount <= turnIndex`. So the snapshot
+ * representing "state before turn N" is the one with the SMALLEST atMessageCount
+ * still greater than turnIndex.
+ *
+ * @param {Array<{atMessageCount:number,id:string,tool?:string}>} marks
+ * @param {number} turnIndex  message index returned by rewindToTurn
+ * @returns {{atMessageCount:number,id:string,tool?:string}|null}
+ */
+export function pickCheckpointForTurn(marks, turnIndex) {
+  if (!Array.isArray(marks) || marks.length === 0) return null;
+  const idx = Number(turnIndex);
+  if (!Number.isFinite(idx)) return null;
+  let best = null;
+  for (const m of marks) {
+    if (!m || typeof m.id !== "string") continue;
+    const c = Number(m.atMessageCount);
+    if (!Number.isFinite(c) || c <= idx) continue;
+    if (best === null || c < Number(best.atMessageCount)) best = m;
+  }
+  return best;
+}
+
+/**
+ * Drop checkpoint marks belonging to turns that were just rewound away (those
+ * with `atMessageCount` greater than the surviving message count). Mutates the
+ * array in place so the REPL's `const` marks array keeps its identity.
+ *
+ * @returns {number} how many marks were removed
+ */
+export function pruneMarksAfter(marks, turnIndex) {
+  if (!Array.isArray(marks)) return 0;
+  const idx = Number(turnIndex);
+  if (!Number.isFinite(idx)) return 0;
+  let removed = 0;
+  for (let i = marks.length - 1; i >= 0; i--) {
+    const c = Number(marks[i]?.atMessageCount);
+    if (!Number.isFinite(c) || c > idx) {
+      marks.splice(i, 1);
+      removed += 1;
+    }
+  }
+  return removed;
+}
+
 /**
  * Offline extractive recap for a resumed conversation ("where were we") —
  * no LLM call: turn counts + last ask + last reply previews.