dskcode 0.1.20 → 0.1.21

package/dist/index.js

@@ -1182,38 +1182,58 @@ function estimateMessageTokens(msg) {
   }
   return estimateTokens(text) + 10;
 }
+function groupIntoTurns(messages) {
+  const turns = [];
+  let current = null;
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      if (current) turns.push(current);
+      current = [msg];
+    } else {
+      if (!current) current = [];
+      current.push(msg);
+    }
+  }
+  if (current && current.length > 0) turns.push(current);
+  return turns;
+}
+function estimateTurnTokens(turn) {
+  let sum = 0;
+  for (const msg of turn) sum += estimateMessageTokens(msg);
+  return sum;
+}
 function trimMessages(messages, opts) {
   const meta = getModelMeta(opts.model);
   const maxInputTokens = meta.contextWindow - opts.reservedForOutput;
   const systemTokens = estimateTokens(opts.systemPrompt);
   let remaining = maxInputTokens - systemTokens;
-  const preserved = [];
+  const turns = groupIntoTurns(messages);
+  const preservedTurns = [];
   let roundsPreserved = 0;
-  for (let i = messages.length - 1; i >= 0 && roundsPreserved < opts.preserveRecentRounds; i--) {
-    preserved.unshift(messages[i]);
-    if (messages[i].role === "user") {
-      roundsPreserved++;
-    }
+  for (let i = turns.length - 1; i >= 0 && roundsPreserved < opts.preserveRecentRounds; i--) {
+    preservedTurns.unshift(turns[i]);
+    roundsPreserved++;
   }
+  const preserved = preservedTurns.flat();
   for (const msg of preserved) {
     remaining -= estimateMessageTokens(msg);
   }
   if (remaining < 0) {
-    while (preserved.length > 1 && remaining < 0) {
-      const removed = preserved.shift();
-      remaining += estimateMessageTokens(removed);
+    while (preservedTurns.length > 1 && remaining < 0) {
+      const dropped = preservedTurns.shift();
+      remaining += estimateTurnTokens(dropped);
     }
-    return [preserved, true];
+    return [preservedTurns.flat(), true];
   }
-  const olderMessages = messages.slice(0, messages.length - preserved.length);
-  const kept = [];
-  for (let i = olderMessages.length - 1; i >= 0; i--) {
-    const cost = estimateMessageTokens(olderMessages[i]);
+  const olderTurns = turns.slice(0, turns.length - preservedTurns.length);
+  const keptTurns = [];
+  for (let i = olderTurns.length - 1; i >= 0; i--) {
+    const cost = estimateTurnTokens(olderTurns[i]);
     if (remaining - cost < 0) break;
     remaining -= cost;
-    kept.unshift(olderMessages[i]);
+    keptTurns.unshift(olderTurns[i]);
   }
-  const result = [...kept, ...preserved];
+  const result = [...keptTurns, ...preservedTurns].flat();
   const trimmed = result.length < messages.length;
   return [result, trimmed];
 }
@@ -1815,7 +1835,8 @@ ${item.result.diff.patch}`;
   async #executeBatch(calls) {
     const toolCtx = {
       cwd: this.#options.cwd,
-      signal: this.#abortController.signal
+      signal: this.#abortController.signal,
+      writeRoots: this.#options.writeRoots
     };
     const allReadOnly = calls.every((tc) => {
       const tool = this.#toolRegistry.get(tc.name);
@@ -1977,6 +1998,39 @@ function resolvePath(inputPath, cwd) {
   const resolved = isAbsolute(inputPath) ? inputPath : resolve(cwd, inputPath);
   return resolve(resolved);
 }
+async function realPath(target) {
+  try {
+    return await realpath2(target);
+  } catch {
+    const parent = resolve(target, "..");
+    try {
+      const realParent = await realpath2(parent);
+      return resolve(realParent, relative(parent, target));
+    } catch {
+      return resolve(target);
+    }
+  }
+}
+async function confine(allowedRoots, target) {
+  if (allowedRoots.length === 0) {
+    return { ok: true };
+  }
+  const realTarget = await realPath(target);
+  for (const root of allowedRoots) {
+    const realRoot = await realPath(root);
+    const rel = relative(realRoot, realTarget);
+    if (!rel.startsWith("..") && rel !== "" && !rel.startsWith("/") && !rel.startsWith("\\")) {
+      return { ok: true };
+    }
+    if (realTarget === realRoot) {
+      return { ok: true };
+    }
+  }
+  return {
+    ok: false,
+    error: `\u8DEF\u5F84 "${target}" \u4E0D\u5728\u5141\u8BB8\u7684\u5199\u5165\u8303\u56F4\u5185 ${allowedRoots.join(", ")}`
+  };
+}
 function truncateOutput(content, maxLength = DEFAULT_MAX_OUTPUT_LENGTH) {
   if (content.length <= maxLength) return content;
   const truncated = content.slice(0, maxLength);
@@ -2320,6 +2374,41 @@ function computeFileDiff(oldContent, newContent, filePath) {
   };
 }
 
+// src/tool/eol.ts
+import { writeFile as writeFile3 } from "fs/promises";
+function detectEol(text) {
+  if (text.length === 0) return "\n";
+  const crlfIdx = text.indexOf("\r\n");
+  const lfIdx = text.indexOf("\n");
+  if (crlfIdx !== -1 && (lfIdx === -1 || crlfIdx <= lfIdx)) {
+    return "\r\n";
+  }
+  return "\n";
+}
+function hasTrailingNewline(text) {
+  return text.endsWith("\n") || text.endsWith("\r\n");
+}
+function normalizeEol(originalContent, newContent) {
+  const targetEol = detectEol(originalContent);
+  const lines = newContent.replace(/\r\n/g, "\n").split("\n");
+  const originalHasTrailing = hasTrailingNewline(originalContent);
+  const newHasTrailing = lines.length > 0 && lines[lines.length - 1] === "";
+  let result = lines.join(targetEol);
+  if (originalHasTrailing && !newHasTrailing) {
+    result += targetEol;
+  }
+  if (!originalHasTrailing && newHasTrailing) {
+    if (result.endsWith(targetEol)) {
+      result = result.slice(0, -targetEol.length);
+    }
+  }
+  return result;
+}
+async function writeFileWithEol(filePath, originalContent, newContent) {
+  const content = originalContent.length > 0 ? normalizeEol(originalContent, newContent) : newContent;
+  await writeFile3(filePath, content, "utf-8");
+}
+
 // src/tool/builtins/read-file.ts
 import { readFile as readFile4, stat } from "fs/promises";
 import { open } from "fs/promises";
@@ -2427,7 +2516,7 @@ var readFileTool = {
 };
 
 // src/tool/builtins/write-file.ts
-import { writeFile as writeFile3, mkdir as mkdir4, readFile as readFile5 } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile5 } from "fs/promises";
 import { dirname, relative as relative3, basename } from "path";
 var writeFileSchema = {
   type: "object",
@@ -2459,6 +2548,12 @@ var writeFileTool = {
     }
     const filePath = resolvePath(params.path, ctx.cwd);
     try {
+      if (ctx.writeRoots && ctx.writeRoots.length > 0) {
+        const conf = await confine(ctx.writeRoots, filePath);
+        if (!conf.ok) {
+          return { success: false, data: conf.error, error: "OUTSIDE_WRITE_ROOTS" };
+        }
+      }
       let oldContent = "";
       let existedBefore = false;
       try {
@@ -2468,7 +2563,7 @@ var writeFileTool = {
       }
       await mkdir4(dirname(filePath), { recursive: true });
       const content = String(params.content);
-      await writeFile3(filePath, content, "utf-8");
+      await writeFileWithEol(filePath, oldContent, content);
       const diff = computeFileDiff(oldContent, content, filePath);
       diff.existedBefore = existedBefore;
       const lineCount = content.split("\n").length;
@@ -2495,7 +2590,7 @@ var writeFileTool = {
 };
 
 // src/tool/builtins/edit-file.ts
-import { readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 import { basename as basename2 } from "path";
 var editFileSchema = {
   type: "object",
@@ -2533,6 +2628,12 @@ var editFileTool = {
       return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 new_text", error: "INVALID_ARGS" };
     }
     const filePath = resolvePath(params.path, ctx.cwd);
+    if (ctx.writeRoots && ctx.writeRoots.length > 0) {
+      const conf = await confine(ctx.writeRoots, filePath);
+      if (!conf.ok) {
+        return { success: false, data: conf.error, error: "OUTSIDE_WRITE_ROOTS" };
+      }
+    }
     try {
       const content = await readFile6(filePath, "utf-8");
       const firstIndex = content.indexOf(params.old_text);
@@ -2552,7 +2653,7 @@ var editFileTool = {
         };
       }
       const newContent = content.replace(params.old_text, params.new_text);
-      await writeFile4(filePath, newContent, "utf-8");
+      await writeFileWithEol(filePath, content, newContent);
       const diff = computeFileDiff(content, newContent, filePath);
       diff.existedBefore = true;
       const beforeText = content.slice(0, firstIndex);
@@ -2582,7 +2683,7 @@ ${oldLines} \u884C \u2192 ${newLines} \u884C
 };
 
 // src/tool/builtins/multi-edit.ts
-import { readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
+import { readFile as readFile7 } from "fs/promises";
 import { basename as basename3 } from "path";
 var multiEditSchema = {
   type: "object",
@@ -2623,6 +2724,12 @@ var multiEditTool = {
       return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 edits\uFF08\u975E\u7A7A\u6570\u7EC4\uFF09", error: "INVALID_ARGS" };
     }
     const filePath = resolvePath(params.path, ctx.cwd);
+    if (ctx.writeRoots && ctx.writeRoots.length > 0) {
+      const conf = await confine(ctx.writeRoots, filePath);
+      if (!conf.ok) {
+        return { success: false, data: conf.error, error: "OUTSIDE_WRITE_ROOTS" };
+      }
+    }
     try {
       const originalContent = await readFile7(filePath, "utf-8");
       let currentContent = originalContent;
@@ -2669,7 +2776,7 @@ var multiEditTool = {
           currentContent = currentContent.replace(step.oldText, step.newText);
         }
       }
-      await writeFile5(filePath, currentContent, "utf-8");
+      await writeFileWithEol(filePath, originalContent, currentContent);
       const diff = computeFileDiff(originalContent, currentContent, filePath);
       diff.existedBefore = true;
       return {
@@ -2692,7 +2799,7 @@ var multiEditTool = {
 };
 
 // src/tool/builtins/delete-range.ts
-import { readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
+import { readFile as readFile8 } from "fs/promises";
 import { basename as basename4 } from "path";
 var deleteRangeSchema = {
   type: "object",
@@ -2750,6 +2857,12 @@ var deleteRangeTool = {
     }
     const filePath = resolvePath(params.path, ctx.cwd);
     const inclusive = params.inclusive ?? false;
+    if (ctx.writeRoots && ctx.writeRoots.length > 0) {
+      const conf = await confine(ctx.writeRoots, filePath);
+      if (!conf.ok) {
+        return { success: false, data: conf.error, error: "OUTSIDE_WRITE_ROOTS" };
+      }
+    }
     try {
       const content = await readFile8(filePath, "utf-8");
       const lines = content.split("\n");
@@ -2781,14 +2894,8 @@ var deleteRangeTool = {
       }
       const newLines = [...lines.slice(0, rangeStart), ...lines.slice(rangeEnd + 1)];
       const newContent = newLines.join("\n");
-      let writeContent = newContent;
-      if (content.endsWith("\n") && !newContent.endsWith("\n")) {
-        writeContent = newContent + "\n";
-      } else if (content.endsWith("\r\n") && !newContent.endsWith("\r\n") && !newContent.endsWith("\n")) {
-        writeContent = newContent + "\r\n";
-      }
-      await writeFile6(filePath, writeContent, "utf-8");
-      const diff = computeFileDiff(content, writeContent, filePath);
+      await writeFileWithEol(filePath, content, newContent);
+      const diff = computeFileDiff(content, newContent, filePath);
       diff.existedBefore = true;
       const deletedLines = rangeEnd - rangeStart + 1;
       const summary = `\u{1F4DD} \u4FEE\u6539: ${basename4(filePath)} (\u5220 ${deletedLines} \u884C, +${diff.additions} -${diff.deletions})`;
@@ -4224,7 +4331,7 @@ function BrickBreakerGame({ onExit: _onExit }) {
   const [initialLevel, setInitialLevel] = useState5(1);
   const [selectingLevel, setSelectingLevel] = useState5(true);
   const stateRef = useRef3(createInitialState(initialLevel));
-  const [tick, setTick] = useState5(0);
+  const [tick2, setTick] = useState5(0);
   const onExitRef = useRef3(_onExit);
   onExitRef.current = _onExit;
   useEffect4(() => {
@@ -4279,7 +4386,7 @@ function BrickBreakerGame({ onExit: _onExit }) {
   const aliveCount = s.bricks.filter((b) => b.alive).length;
   const board = buildBoard(s);
   const def = getLevel(s.level);
-  void tick;
+  void tick2;
   return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", children: [
     /* @__PURE__ */ jsxs10(Box10, { flexDirection: "row", children: [
       /* @__PURE__ */ jsx10(Box10, { width: 20, children: /* @__PURE__ */ jsxs10(Text11, { children: [
@@ -4754,7 +4861,7 @@ function buildGameView(s, scoreLines, scoreColor, message) {
 }
 function CoderCheck({ onExit: _onExit }) {
   const stateRef = useRef4(createInitialState2());
-  const [tick, setTick] = useState6(0);
+  const [tick2, setTick] = useState6(0);
   const [colorOffset, setColorOffset] = useState6(0);
   const onExitRef = useRef4(_onExit);
   onExitRef.current = _onExit;
@@ -4832,7 +4939,7 @@ function CoderCheck({ onExit: _onExit }) {
   const scoreStr = String(s.score).padStart(5, "0");
   const scoreLines = buildScoreLines(scoreStr);
   const view = buildGameView(s, scoreLines, scoreColor, s.message);
-  void tick;
+  void tick2;
   return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", paddingX: 1, children: [
     /* @__PURE__ */ jsx11(Box11, { flexDirection: "row", children: /* @__PURE__ */ jsxs11(Text12, { children: [
       "\u751F\u547D ",
@@ -4889,16 +4996,375 @@ var coder_check_default = {
   }
 };
 
+// src/game/snake/engine.ts
+function isOpposite(a, b) {
+  return a === "UP" && b === "DOWN" || a === "DOWN" && b === "UP" || a === "LEFT" && b === "RIGHT" || a === "RIGHT" && b === "LEFT";
+}
+function samePoint(a, b) {
+  return a.x === b.x && a.y === b.y;
+}
+function movePoint(p, dir) {
+  switch (dir) {
+    case "UP":
+      return { x: p.x, y: p.y - 1 };
+    case "DOWN":
+      return { x: p.x, y: p.y + 1 };
+    case "LEFT":
+      return { x: p.x - 1, y: p.y };
+    case "RIGHT":
+      return { x: p.x + 1, y: p.y };
+  }
+}
+function wrapPoint(p, config) {
+  return {
+    x: (p.x % config.width + config.width) % config.width,
+    y: (p.y % config.height + config.height) % config.height
+  };
+}
+function generateFood(snake, config, type, excludePositions = []) {
+  const occupied = new Set(snake.map((p) => `${p.x},${p.y}`));
+  for (const p of excludePositions) {
+    occupied.add(`${p.x},${p.y}`);
+  }
+  const totalCells = config.width * config.height;
+  if (occupied.size >= totalCells) return null;
+  let pos;
+  do {
+    pos = {
+      x: Math.floor(Math.random() * config.width),
+      y: Math.floor(Math.random() * config.height)
+    };
+  } while (occupied.has(`${pos.x},${pos.y}`));
+  return {
+    position: pos,
+    type,
+    ...type === "special" ? { spawnedAt: Date.now() } : {}
+  };
+}
+function createInitialState3(config) {
+  const startX = Math.floor(config.width / 2);
+  const startY = Math.floor(config.height / 2);
+  const snake = [
+    { x: startX, y: startY },
+    { x: startX - 1, y: startY },
+    { x: startX - 2, y: startY }
+  ];
+  const food = generateFood(snake, config, "normal");
+  return {
+    snake,
+    direction: "RIGHT",
+    nextDirection: "RIGHT",
+    food,
+    specialFood: null,
+    score: 0,
+    speedLevel: 1,
+    isGameOver: false,
+    isPaused: false,
+    wallWrap: Math.random() < 0.5,
+    tickInterval: config.initialSpeed
+  };
+}
+function tick(state, config) {
+  state.direction = state.nextDirection;
+  const head = state.snake[0];
+  let newHead = movePoint(head, state.direction);
+  const outOfBounds = newHead.x < 0 || newHead.x >= config.width || newHead.y < 0 || newHead.y >= config.height;
+  if (outOfBounds) {
+    if (state.wallWrap) {
+      newHead = wrapPoint(newHead, config);
+    } else {
+      state.isGameOver = true;
+      return;
+    }
+  }
+  const ateNormal = samePoint(newHead, state.food.position);
+  const ateSpecial = state.specialFood !== null && samePoint(newHead, state.specialFood.position);
+  const willEat = ateNormal || ateSpecial;
+  const bodyToCheck = willEat ? state.snake : state.snake.slice(0, -1);
+  for (const segment of bodyToCheck) {
+    if (samePoint(newHead, segment)) {
+      state.isGameOver = true;
+      return;
+    }
+  }
+  state.snake.unshift(newHead);
+  if (ateNormal) {
+    state.score += 1;
+    updateSpeed(state, config);
+    const exclude = state.specialFood ? [state.specialFood.position] : [];
+    const newFood = generateFood(state.snake, config, "normal", exclude);
+    if (newFood) {
+      state.food = newFood;
+    } else {
+      state.isGameOver = true;
+      return;
+    }
+    if (state.specialFood === null && Math.random() < 0.25) {
+      state.specialFood = generateFood(state.snake, config, "special", [state.food.position]);
+    }
+  } else if (ateSpecial) {
+    state.score += 3;
+    updateSpeed(state, config);
+    state.specialFood = null;
+  } else {
+    state.snake.pop();
+  }
+  if (state.specialFood?.spawnedAt !== void 0) {
+    if (Date.now() - state.specialFood.spawnedAt > 5e3) {
+      state.specialFood = null;
+    }
+  }
+}
+function updateSpeed(state, config) {
+  const newLevel = Math.floor(state.score / config.scorePerLevel) + 1;
+  state.speedLevel = newLevel;
+  state.tickInterval = Math.max(
+    config.minSpeed,
+    config.initialSpeed - (newLevel - 1) * config.speedDecrement
+  );
+}
+function changeDirection(state, newDir) {
+  if (!isOpposite(newDir, state.direction)) {
+    state.nextDirection = newDir;
+  }
+}
+
+// src/game/snake/renderer.ts
+import chalk4 from "chalk";
+var CELL_W = 2;
+var EMPTY = "  ";
+var BODY_CHAR = "\u2593";
+var HEAD_CHAR = "\u2593";
+var NORMAL_FOOD_CHAR = "\u25C6";
+var SPECIAL_FOOD_CHAR = "\u2605";
+var CSI = "\x1B[";
+var CURSOR_HIDE = `${CSI}?25l`;
+var CURSOR_SHOW = `${CSI}?25h`;
+var CURSOR_HOME = `${CSI}H`;
+function hideCursor() {
+  process.stdout.write(CURSOR_HIDE);
+}
+function showCursor() {
+  process.stdout.write(CURSOR_SHOW);
+}
+function clearScreen() {
+  process.stdout.write(`${CSI}2J${CURSOR_HOME}`);
+}
+function cellColor(char, type) {
+  switch (type) {
+    case "snake-head":
+      return chalk4.greenBright(char);
+    case "snake-body":
+      return chalk4.green(char);
+    case "normal-food":
+      return chalk4.red(char);
+    case "special-food":
+      return chalk4.yellow(char);
+    case "empty":
+      return char;
+  }
+}
+function renderToTerminal(state, config) {
+  const lines = buildRenderLines(state, config);
+  process.stdout.write(`${CSI}2J${CURSOR_HOME}` + lines.join("\n"));
+}
+function buildRenderLines(state, config) {
+  const { width: W, height: H } = config;
+  const lines = [];
+  const grid = Array.from({ length: H }, () => Array(W).fill("empty"));
+  for (let i = 1; i < state.snake.length; i++) {
+    const seg = state.snake[i];
+    if (seg.y >= 0 && seg.y < H && seg.x >= 0 && seg.x < W) {
+      grid[seg.y][seg.x] = "snake-body";
+    }
+  }
+  const head = state.snake[0];
+  if (head.y >= 0 && head.y < H && head.x >= 0 && head.x < W) {
+    grid[head.y][head.x] = "snake-head";
+  }
+  const fp = state.food.position;
+  if (grid[fp.y][fp.x] === "empty") {
+    grid[fp.y][fp.x] = "normal-food";
+  }
+  if (state.specialFood) {
+    const sp = state.specialFood.position;
+    if (grid[sp.y][sp.x] === "empty") {
+      grid[sp.y][sp.x] = "special-food";
+    }
+  }
+  lines.push("  " + chalk4.gray("\u2554" + "\u2550\u2550".repeat(W) + "\u2557"));
+  for (let y = 0; y < H; y++) {
+    let row = "  " + chalk4.gray("\u2551");
+    for (let x = 0; x < W; x++) {
+      const cellType = grid[y][x];
+      let char;
+      switch (cellType) {
+        case "snake-head":
+          char = HEAD_CHAR.repeat(CELL_W);
+          break;
+        case "snake-body":
+          char = BODY_CHAR.repeat(CELL_W);
+          break;
+        case "normal-food":
+          char = NORMAL_FOOD_CHAR + " ";
+          break;
+        case "special-food":
+          char = SPECIAL_FOOD_CHAR + " ";
+          break;
+        default:
+          char = EMPTY;
+      }
+      row += cellColor(char, cellType);
+    }
+    row += chalk4.gray("\u2551");
+    lines.push(row);
+  }
+  lines.push("  " + chalk4.gray("\u255A" + "\u2550\u2550".repeat(W) + "\u255D"));
+  lines.push("");
+  lines.push(
+    `  ${chalk4.cyan("\u5206\u6570")}: ${state.score}  ${chalk4.cyan("\u957F\u5EA6")}: ${state.snake.length}  ${chalk4.cyan("\u901F\u5EA6")}: Lv.${state.speedLevel}  ${chalk4.cyan("\u8FB9\u754C")}: ${state.wallWrap ? "\u7A7F\u5899" : "\u649E\u5899"}`
+  );
+  if (state.specialFood?.spawnedAt !== void 0) {
+    const remaining = Math.ceil((5e3 - (Date.now() - state.specialFood.spawnedAt)) / 1e3);
+    if (remaining > 0) {
+      lines.push(`  ${chalk4.yellow(`\u2B50 \u7279\u6B8A\u98DF\u7269 ${remaining} \u79D2\u540E\u6D88\u5931`)}`);
+    }
+  }
+  lines.push(`  ${chalk4.gray("W/A/S/D \u6216 \u65B9\u5411\u952E\u79FB\u52A8 | P \u6682\u505C | M \u5207\u6362\u6A21\u5F0F | Q \u9000\u51FA")}`);
+  if (state.isPaused) {
+    lines.push("");
+    lines.push(`  ${chalk4.yellow("\u23F8  \u5DF2\u6682\u505C \u2014 \u6309 P \u7EE7\u7EED")}`);
+  }
+  if (state.isGameOver) {
+    lines.push("");
+    lines.push(`  ${chalk4.red.bold("\u{1F480}  \u6E38\u620F\u7ED3\u675F!")}  ${chalk4.cyan("\u6700\u7EC8\u5206\u6570: " + state.score)}`);
+    lines.push(`  ${chalk4.gray("\u6309 R \u91CD\u65B0\u5F00\u59CB | \u6309 Q \u9000\u51FA")}`);
+  }
+  return lines;
+}
+
+// src/game/snake/input.ts
+import * as readline from "readline";
+var KEY_TO_DIR = {
+  up: "UP",
+  w: "UP",
+  W: "UP",
+  down: "DOWN",
+  s: "DOWN",
+  S: "DOWN",
+  left: "LEFT",
+  a: "LEFT",
+  A: "LEFT",
+  right: "RIGHT",
+  d: "RIGHT",
+  D: "RIGHT"
+};
+function setupInput(ctx, onQuit, onRestart) {
+  readline.emitKeypressEvents(process.stdin);
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  const handler = (_, key) => {
+    if (!key || !key.name) return;
+    const { name, ctrl } = key;
+    if (ctrl && (name === "c" || name === "d")) {
+      onQuit();
+      return;
+    }
+    if (name === "q") {
+      onQuit();
+      return;
+    }
+    const state = ctx.state;
+    if (state.isGameOver) {
+      if (name === "r") {
+        ctx.state = onRestart();
+      }
+      return;
+    }
+    if (name === "p") {
+      state.isPaused = !state.isPaused;
+      return;
+    }
+    if (name === "m") {
+      state.wallWrap = !state.wallWrap;
+      return;
+    }
+    const dir = KEY_TO_DIR[name];
+    if (dir) {
+      changeDirection(state, dir);
+    }
+  };
+  process.stdin.on("keypress", handler);
+  return () => {
+    process.stdin.removeListener("keypress", handler);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+  };
+}
+
+// src/game/snake/index.ts
+var CONFIG = {
+  width: 20,
+  height: 16,
+  initialSpeed: 180,
+  minSpeed: 60,
+  speedDecrement: 10,
+  scorePerLevel: 5
+};
+var IDLE_INTERVAL = 200;
+var snakeGame = {
+  id: "snake",
+  name: "Big Snake",
+  description: "\u7ECF\u5178\u8D2A\u5403\u86C7\uFF0C\u53CC\u98DF\u7269\u7CFB\u7EDF\u3001\u96BE\u5EA6\u9012\u589E\u3001\u7A7F\u5899/\u649E\u5899\u6A21\u5F0F",
+  play: async () => {
+    const ctx = { state: createInitialState3(CONFIG) };
+    return new Promise((resolve2) => {
+      const cleanupInput = setupInput(
+        ctx,
+        () => {
+          stop = true;
+          clearTimeout(timerId);
+          showCursor();
+          cleanupInput();
+          resolve2();
+        },
+        () => {
+          return createInitialState3(CONFIG);
+        }
+      );
+      clearScreen();
+      hideCursor();
+      let stop = false;
+      let timerId;
+      function loop() {
+        if (stop) return;
+        const s = ctx.state;
+        if (!s.isGameOver && !s.isPaused) {
+          tick(s, CONFIG);
+        }
+        renderToTerminal(s, CONFIG);
+        const interval = s.isGameOver || s.isPaused ? IDLE_INTERVAL : s.tickInterval;
+        timerId = setTimeout(loop, interval);
+      }
+      timerId = setTimeout(loop, 0);
+    });
+  }
+};
+var snake_default = snakeGame;
+
 // src/game/registry.ts
 function initGames() {
   registerGame(brick_breaker_default);
   registerGame(coder_check_default);
+  registerGame(snake_default);
   return listGames();
 }
 
 // src/cli/index.tsx
 import { render as render4 } from "ink";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 
 // src/stock/StockList.tsx
 import { Box as Box12, Text as Text13, useInput as useInput5 } from "ink";
@@ -5331,7 +5797,7 @@ function createCli() {
       const key = await promptForApiKey();
       if (!key) process.exit(1);
       const savedPath = await saveApiKey(key);
-      console.log(`  ${chalk4.green("\u2714")} API Key \u5DF2\u4FDD\u5B58\u5230 ${chalk4.dim(savedPath)}
+      console.log(`  ${chalk5.green("\u2714")} API Key \u5DF2\u4FDD\u5B58\u5230 ${chalk5.dim(savedPath)}
 `);
       const result = await loadAndValidate();
       ctx = { ...ctx, config: result.config };
@@ -5478,8 +5944,8 @@ compdef _dskcode_completion dskcode`);
         { code: "sh601899" }
       ];
       const savedPath = await saveStockConfig(defaultSymbols);
-      console.log(`${chalk4.green("\u2714")} \u5DF2\u751F\u6210\u81EA\u9009\u80A1\u914D\u7F6E: ${chalk4.dim(savedPath)}`);
-      console.log(`${chalk4.dim("  \u63D0\u793A: \u53EF\u7F16\u8F91\u4E0A\u8FF0\u6587\u4EF6\u81EA\u5B9A\u4E49\u81EA\u9009\u80A1\u5217\u8868")}
+      console.log(`${chalk5.green("\u2714")} \u5DF2\u751F\u6210\u81EA\u9009\u80A1\u914D\u7F6E: ${chalk5.dim(savedPath)}`);
+      console.log(`${chalk5.dim("  \u63D0\u793A: \u53EF\u7F16\u8F91\u4E0A\u8FF0\u6587\u4EF6\u81EA\u5B9A\u4E49\u81EA\u9009\u80A1\u5217\u8868")}
 `);
     }
     const freshResult = await loadAndValidate();
@@ -5533,7 +5999,7 @@ compdef _dskcode_completion dskcode`);
       });
       if (selectedGame) {
         console.log(`
-  \u542F\u52A8\u6E38\u620F: ${chalk4.green(selectedGame.name)}
+  \u542F\u52A8\u6E38\u620F: ${chalk5.green(selectedGame.name)}
 `);
         await selectedGame.play();
       }