@ia-ccun/code-agent-cli 0.0.52-release → 0.0.53

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,10 +48,100 @@ const workingMessages = [
 	"Algorithm", "Architecture", "Database", "Cache", "Queue", "Microservice",
 ];
 
-let intervalId: ReturnType<typeof setInterval> | null = null;
-let startTime = 0;
-let totalTokens = 0;
+/**
+ * 工作消息状态管理器 - 使用 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];
@@ -60,56 +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) {
-	// turn_start 时开始循环切换消息
+	// ✅ 单一状态管理器
+	const state = new WorkingMessageStateManager();
+
+	// ✅ session_shutdown - 清理所有资源
+	pi.on("session_shutdown", async (_event, ctx) => {
+		state.dispose();
+	});
+
+	// ✅ turn_start - 初始化状态并启动定时器
 	pi.on("turn_start", async (_event, ctx) => {
-		if (!ctx.ui) return;
-
-		// 记录开始时间
-		startTime = Date.now();
-		totalTokens = 0;
-
-		// 立即设置第一条
-		const updateMessage = () => {
-			const elapsed = Math.floor((Date.now() - startTime) / 1000);
-			const timeStr = formatTime(elapsed);
-			const tokensStr = formatTokens(totalTokens);
-			// ✶ 和单词显示为主题色
-			const msg = `${accentColor} ✶ ${getNextMessage()}…${reset} (${timeStr} · ↓ ${tokensStr} tokens)`;
-			ctx.ui?.setWorkingMessage(msg);
-		};
-
-		updateMessage();
-
-		// 每3秒更新一次
-		if (!intervalId) {
-			intervalId = setInterval(() => {
-				// 获取当前 tokens 使用量
-				for (const entry of ctx.sessionManager.getBranch()) {
-					if (entry.type === "message" && (entry as any).message?.role === "assistant") {
-						const msg = (entry as any).message as AssistantMessage;
-						if (msg.usage?.output) {
-							totalTokens = msg.usage.output;
-						}
-					}
-				}
-				updateMessage();
-			}, 3000);
+		if (!ctx.ui) {
+			return;
 		}
+
+		// ✅ 重置状态（清理旧资源）
+		state.reset();
+		state.setUI(ctx.ui); // ✅ 明确类型：ExtensionContext['ui']
+		state.setStartTime(Date.now());
+
+		// 设置第一条消息
+		const elapsed = Math.floor((Date.now() - state.startTime) / 1000);
+		const timeStr = formatTime(elapsed);
+		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;
-		}
-		// 恢复默认消息
-		ctx.ui?.setWorkingMessage(undefined);
+		state.dispose();
 	});
-}
+}

package/config/agent/help.md

@@ -470,13 +470,6 @@ aicode-cli --verbose
 | `--theme <name>` | 指定主题 |
 | `--model <name>` | 指定模型 |
 | `--clear` | 启动时清理会话 |
-
-### 相关资源
-
-- **项目仓库**: https://github.com/ia-ccun/code-agent-cli
-- **npm 包**: https://www.npmjs.com/package/@ia-ccun/code-agent-cli
-- **pi-coding-agent**: 底层 Agent 框架
-
 ---
 
 *世界那么哒 · AI 实践落地 @2026*

package/config/agent/models.json

@@ -1,20 +1,20 @@
 {
   "providers": {
-    "local": {
-      "name": "local",
+    "aicode": {
+      "name": "aicode llm",
       "baseUrl": "https://ai-llm.cc.com/v1",
       "api": "openai-completions",
-      "apiKey": "你自己的APIKEY",
+      "apiKey": "你自己的APIKEY sk-xxxxxxxxxxxxxxxxxx",
       "headers": {
         "User-Agent": "${VERSION}"
       },
       "models": [
         {
-          "id": "GLM-4.7-W8A8",
-          "name": "GLM4.7",
-          "contextWindow": 120000,
+          "id": "qwen3.6-35b-a3b",
+          "name": "qwen3.6",
+          "contextWindow": 128000,
           "maxTokens": 100000,
-          "reasoning": true,
+          "reasoning": false,
           "input": ["text"],
           "cost": {
             "input": 5,

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/chroma/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chroma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/config/agent/skills/chroma/chroma-local/SKILL.md

@@ -0,0 +1,165 @@
+---
+name: chroma-local
+description: Use when the user needs self-hosted or local Chroma for semantic search, including `ChromaClient`, `HttpClient`, or Python `EphemeralClient`, local persistence, Docker or `chroma run`, or OSS Chroma without Chroma Cloud features.
+---
+
+## Instructions
+
+Determine these before writing code. Prefer discovering them from the repo and the user request. Ask only when the choice materially changes the implementation.
+
+1. **Runtime shape**
+   - Are they connecting to a running local server, embedding Chroma into tests, or setting up local development from scratch?
+   - Decide whether they need `chroma run`, a Docker or service command, `HttpClient` or `ChromaClient`, or Python `EphemeralClient`.
+
+2. **Persistence**
+   - Persistent local data: choose an intentional data path.
+   - Disposable test data: use defaults or a temp directory.
+
+3. **Embedding model**
+   - Reuse the app's existing embedding provider when possible.
+   - Otherwise default to `@chroma-core/default-embed` in TypeScript or the standard local default in Python.
+   - If the user explicitly wants OpenAI embeddings in TypeScript, install and use `@chroma-core/openai`.
+
+4. **Indexed data shape**
+   - Determine what is being indexed, how it should be chunked, and what metadata is needed for filtering and updates.
+
+## Routing
+
+- **Existing local server**
+  - Confirm host and port before changing client code.
+  - Validate the server is reachable before assuming collections are missing.
+
+- **Fresh local development**
+  - Add a local startup path such as `chroma run` or the repo's existing Docker or service command.
+  - Default to `localhost:8000` unless the repo already uses another address.
+
+- **Python tests or disposable local workflows**
+  - Prefer `EphemeralClient` when persistence is unnecessary.
+  - Call out that data is lost when the process exits.
+
+- **Persistent local development**
+  - Use a stable data path and make persistence explicit in code or config.
+  - Do not silently switch between ephemeral and persistent modes.
+
+- **Search integration work**
+  - Use `getOrCreateCollection()` in TypeScript or `get_or_create_collection()` in Python.
+  - Design document IDs and metadata so upserts and deletes are straightforward.
+  - Batch writes when syncing large datasets.
+
+## Ask vs proceed
+
+**Ask first:**
+- Embedding model choice (cost and quality implications)
+- Whether they need persistent local data
+- How they are starting the local server
+- Multi-tenant data isolation strategy
+
+**Proceed with sensible defaults:**
+- Use `getOrCreateCollection()` (TypeScript) / `get_or_create_collection()` (Python)
+- Use cosine similarity (most common)
+- Chunk size under 8KB
+- Store source IDs in metadata for updates/deletes
+- Use a local server on `localhost:8000` unless the repo already configures another address or is using Python `EphemeralClient`
+
+## What to validate
+
+- Correct client import (`ChromaClient`, `HttpClient`, or `Client`)
+- Embedding function package is installed (TypeScript)
+- Local server is reachable before assuming collections are missing
+- Local path and persistence mode are intentional
+
+## Implementation notes
+
+- Local Chroma is the right default for development, tests, and self-hosted deployments.
+- OSS Chroma does not include Chroma Cloud-only features such as `Schema()` and `Search()`.
+- If the user asks for hybrid dense and sparse retrieval, treat that as a likely Chroma Cloud requirement unless the repo already implements an OSS workaround.
+- For open source Chroma, dense retrieval with a single embedding function is the normal baseline.
+
+## Minimal patterns
+
+Start a local Chroma server when the repo needs one:
+
+```bash
+chroma run
+```
+
+Default address: `localhost:8000`.
+
+TypeScript local client:
+
+```typescript
+import { ChromaClient } from 'chromadb';
+import { DefaultEmbeddingFunction } from '@chroma-core/default-embed';
+
+const client = new ChromaClient();
+
+const embeddingFunction = new DefaultEmbeddingFunction();
+const collection = await client.getOrCreateCollection({
+  name: 'my_collection',
+  embeddingFunction,
+});
+
+// Add documents
+await collection.add({
+  ids: ['doc1', 'doc2'],
+  documents: ['First document text', 'Second document text'],
+});
+
+// Query
+const results = await collection.query({
+  queryTexts: ['search query'],
+  nResults: 5,
+});
+```
+
+Python local client:
+
+```python
+import chromadb
+
+client = chromadb.HttpClient(host="localhost", port=8000)
+
+collection = client.get_or_create_collection(name="my_collection")
+
+# Add documents
+collection.add(
+    ids=["doc1", "doc2"]   ,
+    documents=["First document text", "Second document text"],
+)
+
+# Query
+results = collection.query(
+    query_texts=["search query"],
+    n_results=5,
+)
+```
+
+## Learn More
+
+Fetch Chroma's `llms.txt` only when you need API or product details that are not already in the repo or this skill: https://docs.trychroma.com/llms.txt
+
+## Available Topics
+
+### Typescript
+
+- [Chroma Regex Filtering](./regex/typescript.md) - Learn how to use regex filters in Chroma queries
+- [Query and Get](./querying/typescript.md) - Query and Get Data from Chroma Collections
+- [Metadata](./metadata/typescript.md) - Store and query metadata, including filters and array values
+- [Updating and Deleting](./updating-deleting/typescript.md) - Update existing documents and delete data from collections
+- [Error Handling](./error-handling/typescript.md) - Handling errors and failures when working with Chroma
+- [Local Chroma](./local-chroma/typescript.md) - How to run and use local chroma
+
+### Python
+
+- [Chroma Regex Filtering](./regex/python.md) - Learn how to use regex filters in Chroma queries
+- [Query and Get](./querying/python.md) - Query and Get Data from Chroma Collections
+- [Metadata](./metadata/python.md) - Store and query metadata, including filters and array values
+- [Updating and Deleting](./updating-deleting/python.md) - Update existing documents and delete data from collections
+- [Error Handling](./error-handling/python.md) - Handling errors and failures when working with Chroma
+- [Local Chroma](./local-chroma/python.md) - How to run and use local chroma
+
+## General
+
+- [Data Model](./data-model.md) - An overview of how Chroma stores data
+- [Integrating Chroma into an existing system](./understanding-a-codebase.md) - Guidance for adding Chroma search to an existing application
+- [Chroma CLI](./cli.md) - Starting and managing a local open source Chroma server from the CLI

package/config/agent/skills/chroma/chroma-local/cli.md

@@ -0,0 +1,48 @@
+---
+name: Chroma CLI
+description: Starting and managing a local open source Chroma server from the CLI
+---
+
+## Chroma CLI
+
+The Chroma CLI can also be used for local open source Chroma workflows. This topic focuses on starting and managing a local server, not Chroma Cloud account setup.
+
+### Install
+
+```bash
+pip install chromadb
+```
+
+### Start a local server
+
+Run Chroma locally on the default address:
+
+```bash
+chroma run
+```
+
+This starts a server on `localhost:8000`.
+
+### Choose a persistent data directory
+
+Store local data in a specific path instead of the default working directory:
+
+```bash
+chroma run --path ./chroma-data
+```
+
+### Change the port
+
+If another process already uses port `8000`, pick another one:
+
+```bash
+chroma run --port 8001
+```
+
+Update your client code to match the chosen host and port.
+
+### Local workflow tips
+
+- Use a dedicated data directory per environment so dev and test data do not mix.
+- In tests, use disposable directories or clear collections between runs.
+- Check that the server is running before debugging client-side collection errors.

package/config/agent/skills/chroma/chroma-local/data-model.md

@@ -0,0 +1,103 @@
+---
+name: Data Model
+description: An overview of how Chroma stores data
+---
+
+## Data Model
+
+Use this reference when designing collection layout, chunking, IDs, metadata, and filtering for Chroma.
+
+### Core concepts
+
+**Collections** are the top-level containers, similar to tables in a relational database. Each collection has its own embedding configuration and indexes.
+
+**Documents** are the searchable units within a collection. Each document has:
+- **ID** - A unique string identifier
+- **Content** - The text that gets embedded and searched
+- **Embedding** - The vector representation
+- **Metadata** - Key-value pairs for filtering
+
+## Chunking
+
+Most real-world data is too large to fit in a single document. Chunking splits content into searchable pieces.
+
+### Chunking strategy
+
+**Recommended chunk size:** Keep chunks comfortably below product limits and small enough to preserve search precision and context. Generally, 8KB or less is a good default starting point.
+
+**Good chunking preserves meaning:**
+- Split at natural boundaries (paragraphs, sentences, sections)
+- Don't cut mid-sentence or mid-word
+- Include enough context for the chunk to be meaningful on its own
+
+**Determine from the repo or ask if ambiguous:**
+- What type of content are they indexing?
+- Are there natural boundaries (chapters, sections, records)?
+- How much context does a search result need to be useful?
+
+### Tracking chunks with metadata
+
+When a single source document becomes multiple chunks, use metadata to track the relationship:
+
+```
+{
+  "source_id": "post-123",      // ID in the primary database
+  "source_type": "blog_post",   // Type of content
+  "chunk_index": 0,             // Position in sequence
+  "total_chunks": 3             // Total chunks from this source
+}
+```
+
+This approach is better than encoding information in the document ID because:
+- IDs can be simple UUIDs
+- Metadata is filterable
+- Updates and deletes are easier (filter by `source_id`)
+
+## Collection organization
+
+For multi-tenant applications, separate collections per tenant are a strong default when isolation, deletion, and search quality matter more than minimizing collection count.
+
+**Why this works better:**
+- Nearest neighbor search is more accurate with fewer candidates
+- Lower latency with smaller collections
+- Natural isolation between tenants
+- Easy to delete all tenant data by dropping the collection
+
+**Example:** A knowledge base SaaS might have collections like `kb_customer_123`, `kb_customer_456`, etc.
+
+**Determine from the repo or ask if ambiguous:** What's the smallest logical unit of data isolation in their application?
+
+## Filtering
+
+Metadata filtering reduces the candidate set before vector search runs, making queries faster and more precise.
+
+### Filter operators
+
+| Operator | Description | Types |
+|----------|-------------|-------|
+| `$eq` | Equal (default) | string, int, bool |
+| `$ne` | Not equal | string, int, bool |
+| `$gt`, `$gte` | Greater than (or equal) | int |
+| `$lt`, `$lte` | Less than (or equal) | int |
+| `$in` | In list | string, int |
+| `$nin` | Not in list | string, int |
+| `$and`, `$or` | Logical combinators | filter arrays |
+| `$contains`, `$not_contains` | Check within arrays | arrays of string, int, bool |
+
+### Document content filtering
+
+Beyond metadata, you can filter on the document text itself using `where_document`:
+- `$contains` - Full-text substring search
+- `$regex` - Regular expression matching
+
+## Dense vs sparse vectors
+
+**Dense vectors** (default) are produced by neural embedding models. They capture semantic meaning, so "car" and "automobile" will be similar.
+
+**Sparse vectors** (BM25, SPLADE) are high-dimensional but mostly zeros. They excel at exact keyword matching.
+
+**Hybrid search** combines both, often outperforming either alone. Chroma Cloud supports hybrid search through the Schema and Search APIs.
+
+### Important note
+
+When creating collections, `get_or_create_collection()` accepts either an `embedding_function` OR a `schema`, but not both. Use Schema when you need multiple indexes or sparse embeddings.