@ia-ccun/code-agent-cli 0.0.53 → 0.0.54-beta.1

package/config/agent/extensions/aicode-filter-outputs.ts

@@ -0,0 +1,131 @@
+/**
+ * @author: xujianjiang
+ * AICode 输出脱敏扩展 — 在 LLM 看到工具结果之前，对内容进行过滤和敏感信息替换
+ *
+ * 功能说明：
+ * - 内容级脱敏：API Key、Token、密码、JWT、数据库连接串、私钥等
+ * - 文件级拦截：.env、secrets、credentials 等敏感文件的读取结果整体替换
+ * - 错误透传：工具执行失败时不拦截，保留调试线索
+ * - UI 友好：TUI 模式下弹出 AICode 风格的通知提示
+ *
+ * 触发时机：tool_result 钩子（在 Pi 注入到 LLM 上下文之前生效）
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+type SensitivePattern = {
+  pattern: RegExp;
+  replacement: string;
+};
+
+function redactText(
+  text: string,
+  patterns: SensitivePattern[],
+): { text: string; modified: boolean } {
+  let result = text;
+  let modified = false;
+
+  for (const { pattern, replacement } of patterns) {
+    const redacted = result.replace(pattern, replacement);
+    if (redacted !== result) {
+      modified = true;
+      result = redacted;
+    }
+  }
+
+  return { text: result, modified };
+}
+
+/**
+ * 在 LLM 看到工具结果之前，对内容进行过滤或转换。
+ * 对 API Key、Token、密码等敏感数据进行脱敏。
+ */
+export default function (pi: ExtensionAPI) {
+  const sensitivePatterns: SensitivePattern[] = [
+    { pattern: /\b(sk-[a-zA-Z0-9]{20,})\b/g, replacement: "[OPENAI_KEY_REDACTED]" },
+    { pattern: /\b(sk-ant-[a-zA-Z0-9_-]{20,})\b/g, replacement: "[ANTHROPIC_KEY_REDACTED]" },
+    { pattern: /\b(sk-or-v1-[a-zA-Z0-9_-]{20,})\b/g, replacement: "[OPENROUTER_KEY_REDACTED]" },
+    { pattern: /\b(AIza[a-zA-Z0-9_-]{30,})\b/g, replacement: "[GOOGLE_KEY_REDACTED]" },
+    {
+      pattern: /\b(cf(?:k|ut|at)_[a-zA-Z0-9_-]{41,})\b/g,
+      replacement: "[CLOUDFLARE_TOKEN_REDACTED]",
+    },
+    {
+      pattern: /\b(CLOUDFLARE_API_TOKEN|CF_API_TOKEN)\s*=\s*['"]?[a-zA-Z0-9_-]{40,}['"]?/gi,
+      replacement: "$1=[CLOUDFLARE_TOKEN_REDACTED]",
+    },
+    {
+      pattern: /\b(CLOUDFLARE_API_KEY|CF_API_KEY)\s*=\s*['"]?[a-f0-9]{37,45}['"]?/gi,
+      replacement: "$1=[CLOUDFLARE_KEY_REDACTED]",
+    },
+    { pattern: /\b(npm_[a-zA-Z0-9]{20,})\b/g, replacement: "[NPM_TOKEN_REDACTED]" },
+    { pattern: /\b(glpat-[a-zA-Z0-9_-]{20,})\b/g, replacement: "[GITLAB_TOKEN_REDACTED]" },
+    { pattern: /\b(gh[pousr]_[a-zA-Z0-9]{36,})\b/g, replacement: "[GITHUB_TOKEN_REDACTED]" },
+    { pattern: /\b(xox[baprs]-[a-zA-Z0-9-]{10,})\b/g, replacement: "[SLACK_TOKEN_REDACTED]" },
+    { pattern: /\b(AKIA[A-Z0-9]{16})\b/g, replacement: "[AWS_KEY_REDACTED]" },
+    {
+      pattern: /\b(api[_-]?key|apikey)\s*[=:]\s*['"]?([a-zA-Z0-9_-]{20,})['"]?/gi,
+      replacement: "$1=[REDACTED]",
+    },
+    {
+      pattern: /\b(secret|token|password|passwd|pwd)\s*[=:]\s*['"]?([^\s'"]{8,})['"]?/gi,
+      replacement: "$1=[REDACTED]",
+    },
+    { pattern: /\b(bearer)\s+([a-zA-Z0-9._-]{20,})\b/gi, replacement: "Bearer [REDACTED]" },
+    {
+      pattern: /\beyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}\b/g,
+      replacement: "[JWT_REDACTED]",
+    },
+    { pattern: /(mongodb(\+srv)?:\/\/[^:]+:)[^@]+(@)/gi, replacement: "$1[REDACTED]$3" },
+    { pattern: /(postgres(ql)?:\/\/[^:]+:)[^@]+(@)/gi, replacement: "$1[REDACTED]$3" },
+    { pattern: /(mysql:\/\/[^:]+:)[^@]+(@)/gi, replacement: "$1[REDACTED]$3" },
+    { pattern: /(redis:\/\/[^:]+:)[^@]+(@)/gi, replacement: "$1[REDACTED]$3" },
+    {
+      pattern:
+        /-----BEGIN (RSA |EC |OPENSSH |)PRIVATE KEY-----[\s\S]*?-----END \1PRIVATE KEY-----/g,
+      replacement: "[PRIVATE_KEY_REDACTED]",
+    },
+  ];
+
+  const sensitiveFiles = [
+    /(^|\/)\.env$/,
+    /(^|\/)\.env\.(?!example$)[^/]+$/,
+    /(^|\/)\.dev\.vars($|\.[^/]+$)/,
+    /(^|\/)secrets?\.(json|ya?ml|toml)$/i,
+    /(^|\/)credentials/i,
+  ];
+
+  pi.on("tool_result", async (event, ctx) => {
+    if (event.isError) return undefined;
+
+    if (event.toolName === "read" && typeof event.input.path === "string") {
+      const filePath = event.input.path;
+      if (/(^|\/)\.env\.example$/i.test(filePath)) {
+        return undefined;
+      }
+      for (const pattern of sensitiveFiles) {
+        if (pattern.test(filePath)) {
+          if (ctx.hasUI) ctx.ui.notify(`[AICode] 已脱敏敏感文件内容：${filePath}`, "info");
+          return {
+            content: [{ type: "text", text: `[AICode] 文件 ${filePath} 内容已脱敏，出于安全考虑不予展示` }],
+          };
+        }
+      }
+    }
+
+    let wasModified = false;
+    const content = event.content.map((item) => {
+      if (item.type !== "text") return item;
+      const redacted = redactText(item.text, sensitivePatterns);
+      if (redacted.modified) wasModified = true;
+      return redacted.modified ? { ...item, text: redacted.text } : item;
+    });
+
+    if (wasModified) {
+      if (ctx.hasUI) ctx.ui.notify("[AICode] 已对输出中的敏感信息进行脱敏", "info");
+      return { content };
+    }
+
+    return undefined;
+  });
+}

package/config/agent/extensions/aicode-snake.ts

@@ -0,0 +1,354 @@
+/**
+ * @author: xujianjiang
+ * AICode 贪吃蛇游戏扩展 — 通过 /snake 命令在终端内玩经典贪吃蛇
+ *
+ * 功能说明：
+ * - 经典玩法：方向键或 WASD 控制方向，吃到食物加分
+ * - 状态持久化：游戏可暂停，下次执行 /snake 自动恢复上次进度
+ * - 最高分记录：跨会话保留历史最高分（High Score）
+ * - 自适应渲染：根据终端宽度自动调整游戏区域尺寸
+ * - 简洁控制：ESC 暂停并保存，Q 退出不保存，R/空格 重开
+ *
+ * 使用方法：
+ *   /snake          启动贪吃蛇游戏（无参数则新建游戏或恢复上次进度）
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { matchesKey, visibleWidth } from "@earendil-works/pi-tui";
+
+const GAME_WIDTH = 40;
+const GAME_HEIGHT = 15;
+const TICK_MS = 100;
+
+type Direction = "up" | "down" | "left" | "right";
+type Point = { x: number; y: number };
+
+interface GameState {
+	snake: Point[];
+	food: Point;
+	direction: Direction;
+	nextDirection: Direction;
+	score: number;
+	gameOver: boolean;
+	highScore: number;
+}
+
+function createInitialState(): GameState {
+	const startX = Math.floor(GAME_WIDTH / 2);
+	const startY = Math.floor(GAME_HEIGHT / 2);
+	return {
+		snake: [
+			{ x: startX, y: startY },
+			{ x: startX - 1, y: startY },
+			{ x: startX - 2, y: startY },
+		],
+		food: spawnFood([{ x: startX, y: startY }]),
+		direction: "right",
+		nextDirection: "right",
+		score: 0,
+		gameOver: false,
+		highScore: 0,
+	};
+}
+
+function spawnFood(snake: Point[]): Point {
+	let food: Point;
+	do {
+		food = {
+			x: Math.floor(Math.random() * GAME_WIDTH),
+			y: Math.floor(Math.random() * GAME_HEIGHT),
+		};
+	} while (snake.some((s) => s.x === food.x && s.y === food.y));
+	return food;
+}
+
+class SnakeComponent {
+	private state: GameState;
+	private interval: ReturnType<typeof setInterval> | null = null;
+	private onClose: () => void;
+	private onSave: (state: GameState | null) => void;
+	private tui: { requestRender: () => void };
+	private cachedLines: string[] = [];
+	private cachedWidth = 0;
+	private version = 0;
+	private cachedVersion = -1;
+	private paused: boolean;
+
+	constructor(
+		tui: { requestRender: () => void },
+		onClose: () => void,
+		onSave: (state: GameState | null) => void,
+		savedState?: GameState,
+	) {
+		this.tui = tui;
+		if (savedState && !savedState.gameOver) {
+			// Resume from saved state, start paused
+			this.state = savedState;
+			this.paused = true;
+		} else {
+			// New game or saved game was over
+			this.state = createInitialState();
+			if (savedState) {
+				this.state.highScore = savedState.highScore;
+			}
+			this.paused = false;
+			this.startGame();
+		}
+		this.onClose = onClose;
+		this.onSave = onSave;
+	}
+
+	private startGame(): void {
+		this.interval = setInterval(() => {
+			if (!this.state.gameOver) {
+				this.tick();
+				this.version++;
+				this.tui.requestRender();
+			}
+		}, TICK_MS);
+	}
+
+	private tick(): void {
+		// Apply queued direction change
+		this.state.direction = this.state.nextDirection;
+
+		// Calculate new head position
+		const head = this.state.snake[0];
+		let newHead: Point;
+
+		switch (this.state.direction) {
+			case "up":
+				newHead = { x: head.x, y: head.y - 1 };
+				break;
+			case "down":
+				newHead = { x: head.x, y: head.y + 1 };
+				break;
+			case "left":
+				newHead = { x: head.x - 1, y: head.y };
+				break;
+			case "right":
+				newHead = { x: head.x + 1, y: head.y };
+				break;
+		}
+
+		// Check wall collision
+		if (newHead.x < 0 || newHead.x >= GAME_WIDTH || newHead.y < 0 || newHead.y >= GAME_HEIGHT) {
+			this.state.gameOver = true;
+			return;
+		}
+
+		// Check self collision
+		if (this.state.snake.some((s) => s.x === newHead.x && s.y === newHead.y)) {
+			this.state.gameOver = true;
+			return;
+		}
+
+		// Move snake
+		this.state.snake.unshift(newHead);
+
+		// Check food collision
+		if (newHead.x === this.state.food.x && newHead.y === this.state.food.y) {
+			this.state.score += 10;
+			if (this.state.score > this.state.highScore) {
+				this.state.highScore = this.state.score;
+			}
+			this.state.food = spawnFood(this.state.snake);
+		} else {
+			this.state.snake.pop();
+		}
+	}
+
+	handleInput(data: string): void {
+		// If paused (resuming), wait for any key
+		if (this.paused) {
+			if (matchesKey(data, "escape") || data === "q" || data === "Q") {
+				// Quit without clearing save
+				this.dispose();
+				this.onClose();
+				return;
+			}
+			// Any other key resumes
+			this.paused = false;
+			this.startGame();
+			return;
+		}
+
+		// ESC to pause and save
+		if (matchesKey(data, "escape")) {
+			this.dispose();
+			this.onSave(this.state);
+			this.onClose();
+			return;
+		}
+
+		// Q to quit without saving (clears saved state)
+		if (data === "q" || data === "Q") {
+			this.dispose();
+			this.onSave(null); // Clear saved state
+			this.onClose();
+			return;
+		}
+
+		// Arrow keys or WASD
+		if (matchesKey(data, "up") || data === "w" || data === "W") {
+			if (this.state.direction !== "down") this.state.nextDirection = "up";
+		} else if (matchesKey(data, "down") || data === "s" || data === "S") {
+			if (this.state.direction !== "up") this.state.nextDirection = "down";
+		} else if (matchesKey(data, "right") || data === "d" || data === "D") {
+			if (this.state.direction !== "left") this.state.nextDirection = "right";
+		} else if (matchesKey(data, "left") || data === "a" || data === "A") {
+			if (this.state.direction !== "right") this.state.nextDirection = "left";
+		}
+
+		// Restart on game over
+		if (this.state.gameOver && (data === "r" || data === "R" || data === " ")) {
+			const highScore = this.state.highScore;
+			this.state = createInitialState();
+			this.state.highScore = highScore;
+			this.onSave(null); // Clear saved state on restart
+			this.version++;
+			this.tui.requestRender();
+		}
+	}
+
+	invalidate(): void {
+		this.cachedWidth = 0;
+	}
+
+	render(width: number): string[] {
+		if (width === this.cachedWidth && this.cachedVersion === this.version) {
+			return this.cachedLines;
+		}
+
+		const lines: string[] = [];
+
+		// Each game cell is 2 chars wide to appear square (terminal cells are ~2:1 aspect)
+		const cellWidth = 2;
+		const effectiveWidth = Math.min(GAME_WIDTH, Math.floor((width - 4) / cellWidth));
+		const effectiveHeight = GAME_HEIGHT;
+
+		// Colors
+		const dim = (s: string) => `\x1b[2m${s}\x1b[22m`;
+		const green = (s: string) => `\x1b[32m${s}\x1b[0m`;
+		const red = (s: string) => `\x1b[31m${s}\x1b[0m`;
+		const yellow = (s: string) => `\x1b[33m${s}\x1b[0m`;
+		const bold = (s: string) => `\x1b[1m${s}\x1b[22m`;
+
+		const boxWidth = effectiveWidth * cellWidth;
+
+		// Helper to pad content inside box
+		const boxLine = (content: string) => {
+			const contentLen = visibleWidth(content);
+			const padding = Math.max(0, boxWidth - contentLen);
+			return dim(" │") + content + " ".repeat(padding) + dim("│");
+		};
+
+		// Top border
+		lines.push(this.padLine(dim(` ╭${"─".repeat(boxWidth)}╮`), width));
+
+		// Header with score
+		const scoreText = `Score: ${bold(yellow(String(this.state.score)))}`;
+		const highText = `High: ${bold(yellow(String(this.state.highScore)))}`;
+		const title = `${bold(green("SNAKE"))} │ ${scoreText} │ ${highText}`;
+		lines.push(this.padLine(boxLine(title), width));
+
+		// Separator
+		lines.push(this.padLine(dim(` ├${"─".repeat(boxWidth)}┤`), width));
+
+		// Game grid
+		for (let y = 0; y < effectiveHeight; y++) {
+			let row = "";
+			for (let x = 0; x < effectiveWidth; x++) {
+				const isHead = this.state.snake[0].x === x && this.state.snake[0].y === y;
+				const isBody = this.state.snake.slice(1).some((s) => s.x === x && s.y === y);
+				const isFood = this.state.food.x === x && this.state.food.y === y;
+
+				if (isHead) {
+					row += green("██"); // Snake head (2 chars)
+				} else if (isBody) {
+					row += green("▓▓"); // Snake body (2 chars)
+				} else if (isFood) {
+					row += red("◆ "); // Food (2 chars)
+				} else {
+					row += "  "; // Empty cell (2 spaces)
+				}
+			}
+			lines.push(this.padLine(dim(" │") + row + dim("│"), width));
+		}
+
+		// Separator
+		lines.push(this.padLine(dim(` ├${"─".repeat(boxWidth)}┤`), width));
+
+		// Footer
+		let footer: string;
+		if (this.paused) {
+			footer = `${yellow(bold("PAUSED"))} Press any key to continue, ${bold("Q")} to quit`;
+		} else if (this.state.gameOver) {
+			footer = `${red(bold("GAME OVER!"))} Press ${bold("R")} to restart, ${bold("Q")} to quit`;
+		} else {
+			footer = `↑↓←→ or WASD to move, ${bold("ESC")} pause, ${bold("Q")} quit`;
+		}
+		lines.push(this.padLine(boxLine(footer), width));
+
+		// Bottom border
+		lines.push(this.padLine(dim(` ╰${"─".repeat(boxWidth)}╯`), width));
+
+		this.cachedLines = lines;
+		this.cachedWidth = width;
+		this.cachedVersion = this.version;
+
+		return lines;
+	}
+
+	private padLine(line: string, width: number): string {
+		// Calculate visible length (strip ANSI codes)
+		const visibleLen = line.replace(/\x1b\[[0-9;]*m/g, "").length;
+		const padding = Math.max(0, width - visibleLen);
+		return line + " ".repeat(padding);
+	}
+
+	dispose(): void {
+		if (this.interval) {
+			clearInterval(this.interval);
+			this.interval = null;
+		}
+	}
+}
+
+const SNAKE_SAVE_TYPE = "snake-save";
+
+export default function (pi: ExtensionAPI) {
+	pi.registerCommand("snake", {
+		description: "AICode 贪吃蛇游戏",
+
+		handler: async (_args, ctx) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("[AICode] 贪吃蛇需要交互模式才能运行", "error");
+				return;
+			}
+
+			// Load saved state from session
+			const entries = ctx.sessionManager.getEntries();
+			let savedState: GameState | undefined;
+			for (let i = entries.length - 1; i >= 0; i--) {
+				const entry = entries[i];
+				if (entry.type === "custom" && entry.customType === SNAKE_SAVE_TYPE) {
+					savedState = entry.data as GameState;
+					break;
+				}
+			}
+
+			await ctx.ui.custom((tui, _theme, _kb, done) => {
+				return new SnakeComponent(
+					tui,
+					() => done(undefined),
+					(state) => {
+						// Save or clear state
+						pi.appendEntry(SNAKE_SAVE_TYPE, state);
+					},
+					savedState,
+				);
+			});
+		},
+	});
+}

package/config/agent/settings.json

@@ -1,10 +1,9 @@
 {
   "quietStartup":true,
   "defaultProvider": "aicode",
-  "defaultModel": "qwen3.5-35b-a3b",
+  "defaultModel": "qwen3.6-35b-a3b",
   "theme":"light",
   "extensions":[
-    "~/.aicode-cli/agent/extensions/bash-check.ts",
     "~/.aicode-cli/agent/extensions/context-monitor.ts",
     "~/.aicode-cli/agent/extensions/context.ts",
     "~/.aicode-cli/agent/extensions/custom-footer.ts",
@@ -14,43 +13,43 @@
     "-extensions/aicode-pets.ts"
   ],
   "packages":[  
-    "npm:pi-subagents@0.17.1",
-    "npm:pi-rewind@0.5.0",
-    "npm:pi-mcp-adapter@2.4.0",
+    "npm:pi-subagents",
+    "npm:pi-rewind",
+    "npm:pi-mcp-adapter",
     "npm:@juicesharp/rpiv-todo",
     "npm:@juicesharp/rpiv-ask-user-question",
-    "npm:@samfp/pi-memory@1.1.1"
+    "npm:@samfp/pi-memor"
   ],
   "memory": {
     "localPath": "~/.aicode-cli/memory",
     "lessonInjection": "selective",
-    "consolidationModel": "qwen3.5-35b-a3b"
+    "consolidationModel": "qwen3.6-35b-a3b"
   },
   "subagents": {
     "agentOverrides": {
       "scout": {
-        "model": "qwen3.5-35b-a3b"
+        "model": "qwen3.6-35b-a3b"
       },
       "researcher": {
-        "model": "qwen3.5-35b-a3b"
+        "model": "qwen3.6-35b-a3b"
       },
       "planner": {
-        "model": "qwen3.5-35b-a3b"
+        "model": "qwen3.6-35b-a3b"
       },
       "worker": {
-        "model": "qwen3.5-35b-a3b"
+        "model": "qwen3.6-35b-a3b"
       },
       "reviewer": {
-        "model": "qwen3.5-35b-a3b"
+        "model": "qwen3.6-35b-a3b"
       },
       "context-builder": {
-        "model": "qwen3.5-35b-a3b"
+        "model": "qwen3.6-35b-a3b"
       },
       "oracle": {
-        "model": "qwen3.5-35b-a3b"
+        "model": "qwen3.6-35b-a3b"
       },
       "delegate": {
-        "model": "qwen3.5-35b-a3b"
+        "model": "qwen3.6-35b-a3b"
       }
     }
   }

package/config/agent/skills/hello/SKILL.md

@@ -1,4 +1,4 @@
----
+ ---
 name: hello
 description: "Custom skill example. Use when testing skill functionality or as a template for creating new skills."
 disable-model-invocation: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ia-ccun/code-agent-cli",
-  "version": "0.0.53",
+  "version": "0.0.54-beta.1",
   "description": "AI Coding Agent CLI - 基于OpenClaw🦞底层Agent原理封装的编码智能体（供学习使用）。",
   "type": "module",
   "main": "./dist/index.js",

package/config/agent/skills/refactor/SKILL.md

@@ -1,40 +0,0 @@
----
-name: refactor
-description: "对代码进行重构，提高可读性和可维护性，同时保持功能不变。Use when refactoring code, improving code readability, or optimizing code structure."
-disable-model-invocation: true
-metadata:
-  version: "1.0.0"
-  author: "xujianjiang"
----
-
-# 重构代码 Skill
-
-## 描述
-对代码进行重构，提高可读性和可维护性，同时保持功能不变。
-
-## 触发方式
-`/skill:refactor`
-
-## 执行步骤
-
-1. **分析现有代码**
-   - 读取目标文件
-   - 识别代码异味 (code smells)
-   - 找出可复用的代码
-
-2. **执行重构**
-   - 提取重复代码为函数
-   - 简化复杂的条件逻辑
-   - 重命名变量/函数使其更清晰
-   - 优化类结构
-   - 添加适当的注释
-
-3. **验证功能**
-   - 确保重构后代码功能不变
-   - 运行现有测试确保通过
-
-## 重构原则
-- 保持功能不变
-- 每次只做一个小改动
-- 提交前运行测试
-- 优先处理高风险/高价值部分