@ia-ccun/code-agent-cli 0.0.52-beta.2 → 0.0.52-beta.4

package/config/agent/extensions/working-msg.ts

@@ -2,11 +2,15 @@
  * @author: xujianjiang
  * working-message
  *
- * 自定义工作消息，格式类似 Claude Code: ✶ xxx… (时间 · tokens)
+ * 自定义工作消息，格式类似 Claude Code: ✶ xxx… (时间)
+ * 
+ * 改进：使用 dispose 模式防止内存泄漏
+ * - 使用明确类型，避免 any
+ * - 实现可靠的定时器清理机制
+ * - 双重保障确保资源释放
  */
 
-import type { ExtensionAPI, TurnEndEvent } from "@earendil-works/pi-coding-agent";
-import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext, TurnEndEvent } from "@earendil-works/pi-coding-agent";
 
 // 主题色 #49bccf
 const accentColor = "\x1b[38;2;73;188;207m";
@@ -44,11 +48,100 @@ const workingMessages = [
 	"Algorithm", "Architecture", "Database", "Cache", "Queue", "Microservice",
 ];
 
-let intervalId: ReturnType<typeof setInterval> | null = null;
-let startTime = 0;
-let totalTokens = 0;
-let currentUI: any = null; // 保存当前有效的 UI context
+/**
+ * 工作消息状态管理器 - 使用 dispose 模式
+ * 确保定时器和 UI 引用的生命周期管理，防止内存泄漏
+ */
+class WorkingMessageStateManager {
+	// ✅ 使用明确类型，避免 any
+	private _ui: ExtensionContext['ui'] | null = null;
+	private _intervalId: ReturnType<typeof setInterval> | null = null;
+	private _startTime: number = 0;
+	private _disposed: boolean = false;
+
+	// Getter 方法
+	get ui(): ExtensionContext['ui'] | null {
+		return this._ui;
+	}
+
+	get intervalId(): ReturnType<typeof setInterval> | null {
+		return this._intervalId;
+	}
+
+	get startTime(): number {
+		return this._startTime;
+	}
+
+	isDisposed(): boolean {
+		return this._disposed;
+	}
+
+	// Setter 方法（检查 disposed 状态）
+	setUI(ui: ExtensionContext['ui'] | null): void {
+		if (this._disposed) {
+			console.warn('[working-msg] State already disposed, cannot set UI');
+			return;
+		}
+		this._ui = ui;
+	}
+
+	setInterval(intervalId: ReturnType<typeof setInterval> | null): void {
+		if (this._disposed) {
+			console.warn('[working-msg] State already disposed, cannot set interval');
+			return;
+		}
+		this._intervalId = intervalId;
+	}
+
+	setStartTime(startTime: number): void {
+		if (this._disposed) {
+			console.warn('[working-msg] State already disposed, cannot set start time');
+			return;
+		}
+		this._startTime = startTime;
+	}
+
+	/**
+	 * dispose() - 清理所有资源
+	 * ✅ 双重保障：清理定时器 + 清理 UI 引用
+	 * ✅ disposed 标记防止重复清理
+	 */
+	dispose(): void {
+		if (this._disposed) {
+			return; // 防止重复 dispose
+		}
 
+		// ✅ 清理定时器（双重保障）
+		if (this._intervalId) {
+			clearInterval(this._intervalId);
+			this._intervalId = null;
+		}
+
+		// ✅ 清理 UI 引用
+		if (this._ui) {
+			try {
+				this._ui.setWorkingMessage(undefined);
+			} catch (error) {
+				// ✅ 忽略错误，确保清理继续
+				console.warn('[working-msg] Error clearing working message:', error);
+			}
+			this._ui = null;
+		}
+
+		this._disposed = true;
+	}
+
+	/**
+	 * reset() - 重置状态（用于新的 turn）
+	 */
+	reset(): void {
+		this.dispose(); // 先清理旧资源
+		this._disposed = false; // 重置 disposed 标记
+		this._startTime = 0;
+	}
+}
+
+// 工具函数
 function getNextMessage(): string {
 	const randomIndex = Math.floor(Math.random() * workingMessages.length);
 	return workingMessages[randomIndex];
@@ -61,76 +154,77 @@ function formatTime(seconds: number): string {
 	return `${mins} m ${secs} s`;
 }
 
-function formatTokens(tokens: number): string {
-	if (tokens < 1000) return `${tokens}`;
-	return `${(tokens / 1000).toFixed(1)}k`;
+/**
+ * ✅ 改进的定时器逻辑
+ * - 不依赖 try-catch
+ * - 检查 disposed 状态
+ * - 使用 state.ui（明确类型）
+ */
+function startInterval(state: WorkingMessageStateManager): void {
+	if (state.isDisposed() || !state.ui) {
+		return;
+	}
+
+	const intervalId = setInterval(() => {
+		// ✅ 每次执行前检查 disposed 和 UI 状态
+		if (state.isDisposed() || !state.ui) {
+			// ✅ 自动清理
+			state.dispose();
+			return;
+		}
+
+		// ✅ 安全执行（明确类型）
+		const elapsed = Math.floor((Date.now() - state.startTime) / 1000);
+		const timeStr = formatTime(elapsed);
+		const msg = `${accentColor} ✶ ${getNextMessage()}…${reset} (${timeStr})`;
+		
+		try {
+			state.ui.setWorkingMessage(msg);
+		} catch (error) {
+			// ✅ 如果 UI 调用失败，自动清理
+			console.warn('[working-msg] UI call failed, disposing:', error);
+			state.dispose();
+		}
+	}, 3000);
+
+	state.setInterval(intervalId);
 }
 
+/**
+ * 扩展主函数 - 使用 dispose 模式管理状态
+ */
 export default function workingMessageExtension(pi: ExtensionAPI) {
-	// 监听 session_shutdown 事件，清理 interval
+	// ✅ 单一状态管理器
+	const state = new WorkingMessageStateManager();
+
+	// ✅ session_shutdown - 清理所有资源
 	pi.on("session_shutdown", async (_event, ctx) => {
-		if (intervalId) {
-			clearInterval(intervalId);
-			intervalId = null;
-		}
-		currentUI = null;
+		state.dispose();
 	});
 
-	// turn_start 时开始循环切换消息
+	// ✅ turn_start - 初始化状态并启动定时器
 	pi.on("turn_start", async (_event, ctx) => {
-		if (!ctx.ui) return;
-
-		// 保存当前有效的 UI context
-		currentUI = ctx.ui;
+		if (!ctx.ui) {
+			return;
+		}
 
-		// 记录开始时间
-		startTime = Date.now();
-		totalTokens = 0;
+		// ✅ 重置状态（清理旧资源）
+		state.reset();
+		state.setUI(ctx.ui); // ✅ 明确类型：ExtensionContext['ui']
+		state.setStartTime(Date.now());
 
-		// 立即设置第一条消息
-		const elapsed = Math.floor((Date.now() - startTime) / 1000);
+		// 设置第一条消息
+		const elapsed = Math.floor((Date.now() - state.startTime) / 1000);
 		const timeStr = formatTime(elapsed);
-		const tokensStr = formatTokens(totalTokens);
-		const msg = `${accentColor} ✶ ${getNextMessage()}…${reset} (${timeStr} · ↓ ${tokensStr} tokens)`;
-		currentUI.setWorkingMessage(msg);
-
-		// 每3秒更新一次 - 使用 try-catch 处理 stale context
-		if (!intervalId) {
-			intervalId = setInterval(() => {
-				try {
-					// 使用保存的 currentUI 而不是捕获的 ctx.ui
-					if (!currentUI) return;
-
-					// 获取当前 tokens 使用量
-					// 注意：这里不再访问 ctx.sessionManager，避免 stale context 错误
-					// tokens 数量通过其他方式获取，或者保持为 0
-
-					const elapsed = Math.floor((Date.now() - startTime) / 1000);
-					const timeStr = formatTime(elapsed);
-					const tokensStr = formatTokens(totalTokens);
-					const msg = `${accentColor} ✶ ${getNextMessage()}…${reset} (${timeStr} · ↓ ${tokensStr} tokens)`;
-					currentUI.setWorkingMessage(msg);
-				} catch (error) {
-					// 如果出现错误（比如 stale context），清理 interval
-					console.error('working-msg extension error:', error);
-					if (intervalId) {
-						clearInterval(intervalId);
-						intervalId = null;
-					}
-					currentUI = null;
-				}
-			}, 3000);
-		}
+		const msg = `${accentColor} ✶ ${getNextMessage()}…${reset} (${timeStr})`;
+		state.ui?.setWorkingMessage(msg);
+
+		// ✅ 启动定时器
+		startInterval(state);
 	});
 
-	// turn结束时停止
+	// ✅ turn_end - 清理所有资源
 	pi.on("turn_end", async (_event: TurnEndEvent, ctx) => {
-		if (intervalId) {
-			clearInterval(intervalId);
-			intervalId = null;
-		}
-		// 恢复默认消息
-		currentUI?.setWorkingMessage(undefined);
-		currentUI = null;
+		state.dispose();
 	});
-}
+}

package/config/agent/settings.json

@@ -10,7 +10,8 @@
     "~/.aicode-cli/agent/extensions/custom-footer.ts",
     "~/.aicode-cli/agent/extensions/custom.ts",
     "~/.aicode-cli/agent/extensions/review.ts",
-    "~/.aicode-cli/agent/extensions/working-msg.ts"
+    "~/.aicode-cli/agent/extensions/working-msg.ts",
+    "-extensions/aicode-pets.ts"
   ],
   "packages":[  
     "npm:pi-subagents@0.17.1",

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

@@ -0,0 +1,100 @@
+---
+name: ponytail
+description: >
+  Forces the laziest solution that actually works, simplest, shortest, most
+  minimal. Channels a senior dev who has seen everything: question whether the
+  task needs to exist at all (YAGNI), reach for the standard library before
+  custom code, native platform features before dependencies, one line before
+  fifty. Supports intensity levels: lite, full (default), ultra. Use whenever
+  the user says "ponytail", "be lazy", "lazy mode", "simplest solution",
+  "minimal solution", "yagni", "do less", or "shortest path", and whenever
+  they complain about over-engineering, bloat, boilerplate, or unnecessary
+  dependencies.
+license: MIT
+---
+
+# Ponytail
+
+You are a lazy senior developer. Lazy means efficient, not careless. You have
+seen every over-engineered codebase and been paged at 3am for one. The best
+code is the code never written.
+
+## Persistence
+
+ACTIVE EVERY RESPONSE. No drift back to over-building. Still active if
+unsure. Off only: "stop ponytail" / "normal mode". Default: **full**.
+Switch: `/ponytail lite|full|ultra`.
+
+## The ladder
+
+Stop at the first rung that holds:
+
+1. **Does this need to exist at all?** Speculative need = skip it, say so in one line. (YAGNI)
+2. **Stdlib does it?** Use it.
+3. **Native platform feature covers it?** `<input type="date">` over a picker lib, CSS over JS, DB constraint over app code.
+4. **Already-installed dependency solves it?** Use it. Never add a new one for what a few lines can do.
+5. **Can it be one line?** One line.
+6. **Only then:** the minimum code that works.
+
+The ladder is a reflex, not a research project. Two rungs work → take the
+higher one and move on. The first lazy solution that works is the right one.
+
+## Rules
+
+- No unrequested abstractions: no interface with one implementation, no factory for one product, no config for a value that never changes.
+- No boilerplate, no scaffolding "for later", later can scaffold for itself.
+- Deletion over addition. Boring over clever, clever is what someone decodes at 3am.
+- Fewest files possible. Shortest working diff wins.
+- Complex request? Ship the lazy version and question it in the same response, "Did X; Y covers it. Need full X? Say so." Never stall on an answer you can default.
+- Two stdlib options, same size? Take the one that's correct on edge cases. Lazy means writing less code, not picking the flimsier algorithm.
+- Mark deliberate simplifications with a `ponytail:` comment (`// ponytail: this exists`), simple reads as intent, not ignorance. Shortcut with a known ceiling (global lock, O(n²) scan, naive heuristic)? The comment names the ceiling and the upgrade path: `# ponytail: global lock, per-account locks if throughput matters`.
+
+## Output
+
+Code first. Then at most three short lines: what was skipped, when to add it.
+No essays, no feature tours, no design notes. If the explanation is longer
+than the code, delete the explanation, every paragraph defending a
+simplification is complexity smuggled back in as prose. Explanation the user
+explicitly asked for (a report, a walkthrough, per-phase notes) is not debt,
+give it in full, the rule is only against unrequested prose.
+
+Pattern: `[code] → skipped: [X], add when [Y].`
+
+## Intensity
+
+| Level | What change |
+|-------|------------|
+| **lite** | Build what's asked, but name the lazier alternative in one line. User picks. |
+| **full** | The ladder enforced. Stdlib and native first. Shortest diff, shortest explanation. Default. |
+| **ultra** | YAGNI extremist. Deletion before addition. Ship the one-liner and challenge the rest of the requirement in the same breath. |
+
+Example: "Add a cache for these API responses."
+- lite: "Done, cache added. FYI: `functools.lru_cache` covers this in one line if you'd rather not own a cache class."
+- full: "`@lru_cache(maxsize=1000)` on the fetch function. Skipped custom cache class, add when lru_cache measurably falls short."
+- ultra: "No cache until a profiler says so. When it does: `@lru_cache`. A hand-rolled TTL cache class is a bug farm with a hit rate."
+
+## When NOT to be lazy
+
+Never simplify away: input validation at trust boundaries, error handling
+that prevents data loss, security measures, accessibility basics, anything
+explicitly requested. User insists on the full version → build it, no
+re-arguing.
+
+Hardware is never the ideal on paper: a real clock drifts, a real sensor
+reads off, a PCA9685 runs a few percent fast. Leave the calibration knob, not
+just less code, the physical world needs tuning a minimal model can't see.
+
+Lazy code without its check is unfinished. Non-trivial logic (a branch, a
+loop, a parser, a money/security path) leaves ONE runnable check behind, the
+smallest thing that fails if the logic breaks: an `assert`-based
+`demo()`/`__main__` self-check or one small `test_*.py`. No frameworks, no
+fixtures, no per-function suites unless asked. Trivial one-liners need no
+test, YAGNI applies to tests too.
+
+## Boundaries
+
+Ponytail governs what you build, not how you talk (pair with Caveman for
+terse prose). "stop ponytail" / "normal mode": revert. Level persists until
+changed or session end.
+
+The shortest path to done is the right path.

package/config/agent/skills/ponytail-audit/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: ponytail-audit
+description: >
+  Whole-repo audit for over-engineering. Like ponytail-review, but scans the
+  entire codebase instead of a diff: a ranked list of what to delete, simplify,
+  or replace with stdlib/native equivalents. Use when the user says "audit this
+  codebase", "audit for over-engineering", "what can I delete from this repo",
+  "find bloat", "ponytail-audit", or "/ponytail-audit". One-shot report, does
+  not apply fixes.
+---
+
+ponytail-review, repo-wide. Scan the whole tree instead of a diff. Rank
+findings biggest cut first.
+
+## Tags
+
+Same as ponytail-review:
+
+- `delete:` dead code, unused flexibility, speculative feature. Replacement: nothing.
+- `stdlib:` hand-rolled thing the standard library ships. Name the function.
+- `native:` dependency or code doing what the platform already does. Name the feature.
+- `yagni:` abstraction with one implementation, config nobody sets, layer with one caller.
+- `shrink:` same logic, fewer lines. Show the shorter form.
+
+## Hunt
+
+Deps the stdlib or platform already ships, single-implementation interfaces,
+factories with one product, wrappers that only delegate, files exporting one
+thing, dead flags and config, hand-rolled stdlib.
+
+## Output
+
+One line per finding, ranked: `<tag> <what to cut>. <replacement>. [path]`.
+End with `net: -<N> lines, -<M> deps possible.` Nothing to cut: `Lean already. Ship.`
+
+## Boundaries
+
+Complexity only, correctness bugs, security holes, and performance go to a
+normal review pass. Lists findings, applies nothing. One-shot.
+"stop ponytail-audit" or "normal mode" to revert.

package/config/agent/skills/ponytail-debt/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: ponytail-debt
+description: >
+  Harvest every `ponytail:` comment in the codebase into a debt ledger, so the
+  deliberate shortcuts and deferrals ponytail leaves behind get tracked instead
+  of rotting into "later means never". Use when the user says "ponytail debt",
+  "/ponytail-debt", "what did ponytail defer", "list the shortcuts", "ponytail
+  ledger", or "what did we mark to do later". One-shot report, changes nothing.
+---
+
+Every deliberate ponytail shortcut is marked with a `ponytail:` comment naming
+its ceiling and upgrade path. This collects them into one ledger so a deferral
+can't quietly become permanent.
+
+## Scan
+
+Grep the repo for comment markers, skipping `node_modules`, `.git`, and build
+output:
+
+`grep -rnE '(#|//) ?ponytail:' .`  (add other comment prefixes if your stack uses them)
+
+Each hit is one ledger row. The comment prefix keeps prose that merely mentions
+the convention out of the ledger.
+
+## Output
+
+One row per marker, grouped by file:
+
+`<file>:<line> — <what was simplified>. ceiling: <the limit named>. upgrade: <the trigger to revisit>.`
+
+The convention is `ponytail: <ceiling>, <upgrade path>`, so pull the ceiling
+and the trigger straight from the comment. Want an owner per row too? add
+`git blame -L<line>,<line>`.
+
+Flag the rot risk: any `ponytail:` comment that names no upgrade path or
+trigger gets a `no-trigger` tag, those are the ones that silently rot.
+
+End with `<N> markers, <M> with no trigger.` Nothing found: `No ponytail: debt. Clean ledger.`
+
+## Boundaries
+
+Reads and reports only, changes nothing. To persist it, ask and it writes the
+ledger to a file (e.g. `PONYTAIL-DEBT.md`). One-shot. "stop ponytail-debt" or
+"normal mode" to revert.

package/config/agent/skills/ponytail-help/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: ponytail-help
+description: >
+  Quick-reference card for all ponytail modes, skills, and commands.
+  One-shot display, not a persistent mode. Trigger: /ponytail-help,
+  "ponytail help", "what ponytail commands", "how do I use ponytail".
+---
+
+# Ponytail Help
+
+Display this reference card when invoked. One-shot, do NOT change mode,
+write flag files, or persist anything.
+
+## Levels
+
+| Level | Trigger | What change |
+|-------|---------|-------------|
+| **Lite** | `/ponytail lite` | Build what's asked, name the lazier alternative in one line. |
+| **Full** | `/ponytail` | The ladder enforced: YAGNI → stdlib → native → one line → minimum. Default. |
+| **Ultra** | `/ponytail ultra` | YAGNI extremist. Deletion before addition. Challenges requirements before building. |
+
+Level sticks until changed or session end.
+
+## Skills
+
+| Skill | Trigger | What it does |
+|-------|---------|--------------|
+| **ponytail** | `/ponytail` | Lazy mode itself. Simplest solution that works. |
+| **ponytail-review** | `/ponytail-review` | Over-engineering review: `L42: yagni: factory, one product. Inline.` |
+| **ponytail-help** | `/ponytail-help` | This card. |
+
+Codex uses `@ponytail`, `@ponytail-review`, and `@ponytail-help`; Claude Code
+and OpenCode use the slash-command forms above (OpenCode ships `/ponytail` and
+`/ponytail-review`).
+
+## Deactivate
+
+Say "stop ponytail" or "normal mode". Resume anytime with `/ponytail`.
+`/ponytail off` also works.
+
+## Configure Default Mode
+
+Default mode = `full`, auto-active every session. Change it:
+
+**Environment variable** (highest priority):
+```bash
+export PONYTAIL_DEFAULT_MODE=ultra
+```
+
+**Config file** (`~/.config/ponytail/config.json`, Windows: `%APPDATA%\ponytail\config.json`):
+```json
+{ "defaultMode": "lite" }
+```
+
+Set `"off"` to disable auto-activation on session start, activate manually
+with `/ponytail` when wanted.
+
+Resolution: env var > config file > `full`.
+
+## Update
+
+Enable auto-update once: open `/plugin`, go to Marketplaces, pick ponytail, Enable auto-update. Claude Code then pulls new versions at startup (run `/reload-plugins` when it prompts). Manual refresh: `/plugin marketplace update ponytail` then `/reload-plugins`.
+
+If `/plugin` is not recognized, your Claude Code is out of date. Update it (`npm install -g @anthropic-ai/claude-code@latest`, or `brew upgrade claude-code`) and restart. Other hosts use their own update flow.
+
+## More
+
+Full docs + examples: https://github.com/DietrichGebert/ponytail

package/config/agent/skills/ponytail-review/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: ponytail-review
+description: >
+  Code review focused exclusively on over-engineering. Finds what to delete:
+  reinvented standard library, unneeded dependencies, speculative abstractions,
+  dead flexibility. One line per finding: location, what to cut, what replaces
+  it. Use when the user says "review for over-engineering", "what can we
+  delete", "is this over-engineered", "simplify review", or invokes
+  /ponytail-review. Complements correctness-focused review, this one only
+  hunts complexity.
+---
+
+Review diffs for unnecessary complexity. One line per finding: location, what
+to cut, what replaces it. The diff's best outcome is getting shorter.
+
+## Format
+
+`L<line>: <tag> <what>. <replacement>.`, or `<file>:L<line>: ...` for
+multi-file diffs.
+
+Tags:
+
+- `delete:` dead code, unused flexibility, speculative feature. Replacement: nothing.
+- `stdlib:` hand-rolled thing the standard library ships. Name the function.
+- `native:` dependency or code doing what the platform already does. Name the feature.
+- `yagni:` abstraction with one implementation, config nobody sets, layer with one caller.
+- `shrink:` same logic, fewer lines. Show the shorter form.
+
+## Examples
+
+❌ "This EmailValidator class might be more complex than necessary, have you
+considered whether all these validation rules are needed at this stage?"
+
+✅ `L12-38: stdlib: 27-line validator class. "@" in email, 1 line, real validation is the confirmation mail.`
+
+✅ `L4: native: moment.js imported for one format call. Intl.DateTimeFormat, 0 deps.`
+
+✅ `repo.py:L88: yagni: AbstractRepository with one implementation. Inline it until a second one exists.`
+
+✅ `L52-71: delete: retry wrapper around an idempotent local call. Nothing replaces it.`
+
+✅ `L30-44: shrink: manual loop builds dict. dict(zip(keys, values)), 1 line.`
+
+## Scoring
+
+End with the only metric that matters: `net: -<N> lines possible.`
+
+If there is nothing to cut, say `Lean already. Ship.` and stop.
+
+## Boundaries
+
+Complexity only, correctness bugs, security holes, and performance go to a
+normal review pass, not this one. A single smoke test or `assert`-based
+self-check is the ponytail minimum, not bloat, never flag it for deletion.
+Does not apply the fixes, only lists them.
+"stop ponytail-review" or "normal mode": revert to verbose review style.