zhitalk 0.0.0 → 0.0.3

package/CLAUDE.md

@@ -0,0 +1,98 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Zhitalk is a personal AI Agent (like OpenClaw) running in the terminal. It uses LangGraph for agent orchestration, Moonshot Kimi as the LLM, and Commander.js for CLI commands.
+
+## Commands
+
+```bash
+pnpm dev        # Run with ts-node (development)
+pnpm test       # Run tests
+pnpm test:watch # Run tests in watch mode
+pnpm test:coverage # Run tests with coverage
+pnpm build      # Compile TypeScript, copy skills, fix permissions
+pnpm start      # Run compiled output from dist/
+pnpm clean      # Remove dist directory
+```
+
+Run a single test with `pnpm test -- <pattern>`.
+
+## Architecture
+
+See [`src/agent/CLAUDE.md`](src/agent/CLAUDE.md) for details on the agent graph, tools, skills, memory, and session management.
+
+## TypeScript Config
+
+Module type is `commonjs`, output goes to `dist/`. The build script also copies `src/agent/skills/` to `dist/agent/skills/` and makes the CLI executable.
+
+## Testing
+
+Jest with ts-jest preset. Test files match `**/*.test.ts`. Run a single test with `pnpm test -- <pattern>`.
+
+## behavior rules
+
+**Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment.
+
+### 1. Think Before Coding
+
+**Don't assume. Don't hide confusion. Surface tradeoffs.**
+
+Before implementing:
+
+- State your assumptions explicitly. If uncertain, ask.
+- If multiple interpretations exist, present them - don't pick silently.
+- If a simpler approach exists, say so. Push back when warranted.
+- If something is unclear, stop. Name what's confusing. Ask.
+
+### 2. Simplicity First
+
+**Minimum code that solves the problem. Nothing speculative.**
+
+- No features beyond what was asked.
+- No abstractions for single-use code.
+- No "flexibility" or "configurability" that wasn't requested.
+- No error handling for impossible scenarios.
+- If you write 200 lines and it could be 50, rewrite it.
+
+Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
+
+### 3. Surgical Changes
+
+**Touch only what you must. Clean up only your own mess.**
+
+When editing existing code:
+
+- Don't "improve" adjacent code, comments, or formatting.
+- Don't refactor things that aren't broken.
+- Match existing style, even if you'd do it differently.
+- If you notice unrelated dead code, mention it - don't delete it.
+
+When your changes create orphans:
+
+- Remove imports/variables/functions that YOUR changes made unused.
+- Don't remove pre-existing dead code unless asked.
+
+The test: Every changed line should trace directly to the user's request.
+
+### 4. Goal-Driven Execution
+
+**Define success criteria. Loop until verified.**
+
+Transform tasks into verifiable goals:
+
+- "Add validation" → "Write tests for invalid inputs, then make them pass"
+- "Fix the bug" → "Write a test that reproduces it, then make it pass"
+- "Refactor X" → "Ensure tests pass before and after"
+
+For multi-step tasks, state a brief plan:
+
+```
+1. [Step] → verify: [check]
+2. [Step] → verify: [check]
+3. [Step] → verify: [check]
+```
+
+Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.

package/README.md

@@ -1,3 +1,38 @@
 # Zhitalk
 
-WIP...
+A personal AI Agent like OpenClaw, including tools, skills, memory, hook, sub-agent, MCP sever, etc. Run in the terminal.
+
+## Usage
+
+Docs https://zhitalk.chat/
+
+Install
+
+```
+npm install zhitalk -g
+```
+
+Run in terminal
+
+```
+zhitalk
+```
+
+## Dev
+
+### Tech
+
+- runtime: nodejs
+- language: typescript
+- package tool: pnpm
+- agent framework: langGraph
+- CLI tool: commander.js
+- database: sqlite
+
+### Command
+
+```bash
+pnpm dev
+pnpm test
+pnpm build
+```

package/dist/agent/agent.d.ts

@@ -0,0 +1,24 @@
+import { type UsageMetadata } from '@langchain/core/messages';
+export declare function initAgent(): Promise<void>;
+/**
+ * 以流式方式运行 agent，将 token 逐个回调给调用方
+ * @param {string} userMessage - 当前用户输入（历史已由 checkpointer 自动续接）
+ * @param {Function} onToken   - 每个 token 到来时的回调 (token: string) => void
+ * @param {Function} onToolConfirmation - tool 调用前的确认回调，返回 true 则执行，false 则拒绝
+ * @param {string} threadId    - 会话 ID，相同 ID 自动续上历史记录
+ * @returns {Promise<{ response: string; usageMetadata?: UsageMetadata }>}  完整的 AI 回复文本及 token 使用信息
+ */
+export declare function runAgentStream(userMessage: string, onToken: (token: string) => void, onToolConfirmation: (toolCalls: any[]) => Promise<boolean>, threadId?: string, signal?: AbortSignal): Promise<{
+    response: string;
+    usageMetadata?: UsageMetadata;
+}>;
+/**
+ * 启动一个 subagent 执行独立任务，完成后返回结果
+ * @param {string} prompt - 给 subagent 的任务提示
+ * @returns {Promise<string>} subagent 的最终回复
+ */
+export declare function runSubAgent(prompt: string): Promise<string>;
+export declare function compressContext(threadId: string): Promise<{
+    didCompress: boolean;
+    count: number;
+}>;

package/dist/agent/agent.js

@@ -0,0 +1,345 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initAgent = initAgent;
+exports.runAgentStream = runAgentStream;
+exports.runSubAgent = runSubAgent;
+exports.compressContext = compressContext;
+const langgraph_checkpoint_sqlite_1 = require("@langchain/langgraph-checkpoint-sqlite");
+const messages_1 = require("@langchain/core/messages");
+const langgraph_1 = require("@langchain/langgraph");
+const langgraph_2 = require("@langchain/langgraph");
+const db_1 = require("./db");
+const tools_1 = require("./tools");
+const context_1 = require("./context");
+const prompt_1 = require("./prompt");
+const colors_1 = require("./colors");
+const read_1 = require("./permission/read");
+const write_1 = require("./permission/write");
+const exec_1 = require("./permission/exec");
+const network_1 = require("./permission/network");
+const hooks_1 = require("./hooks");
+const model_1 = require("./model");
+// ── 模型 ──────────────────────────────────────────────────
+const model = (0, model_1.createModel)({ streaming: true });
+// ── State Schema ──────────────────────────────────────────
+const StateAnnotation = langgraph_1.Annotation.Root({
+    messages: (0, langgraph_1.Annotation)({
+        reducer: langgraph_2.messagesStateReducer,
+        default: () => [],
+    }),
+    contextSummary: (0, langgraph_1.Annotation)({
+        reducer: (_prev, next) => next,
+        default: () => null,
+    }),
+    compressionCount: (0, langgraph_1.Annotation)({
+        reducer: (_prev, next) => next,
+        default: () => 0,
+    }),
+    lastCompressedIndex: (0, langgraph_1.Annotation)({
+        reducer: (_prev, next) => next,
+        default: () => 0,
+    }),
+});
+// ── Graph Nodes ───────────────────────────────────────────
+function shouldContinue(state) {
+    const lastMessage = state.messages[state.messages.length - 1];
+    if (messages_1.AIMessage.isInstance(lastMessage) && lastMessage.tool_calls?.length) {
+        return 'tools';
+    }
+    return langgraph_1.END;
+}
+function simplifyToolMessages(messages) {
+    const toolIndices = [];
+    for (let i = 0; i < messages.length; i++) {
+        if (messages[i].type === 'tool') {
+            toolIndices.push(i);
+        }
+    }
+    const recentKeep = 6;
+    const recentToolIndices = new Set(toolIndices.slice(0 - recentKeep));
+    return messages.map((msg, i) => {
+        if (msg.type !== 'tool')
+            return msg;
+        if (recentToolIndices.has(i))
+            return msg;
+        const toolMsg = msg;
+        if (toolMsg.name === 'read_file')
+            return msg;
+        return new messages_1.ToolMessage({
+            content: `[Previous: used ${toolMsg.name}]`,
+            tool_call_id: toolMsg.tool_call_id,
+            name: toolMsg.name,
+        });
+    });
+}
+// ── 记忆 ──────────────────────────────────────────────────
+const checkpointer = langgraph_checkpoint_sqlite_1.SqliteSaver.fromConnString(db_1.DB_PATH);
+// ── Agent Graph 工厂 ──────────────────────────────────────
+function createAgentGraph(toolList) {
+    const modelWithTheseTools = model.bindTools(toolList);
+    async function modelRequest(state, config) {
+        let modelMessages = state.messages ?? [];
+        // compact context
+        if (state.contextSummary && state.lastCompressedIndex > 0) {
+            const summaryMsg = new messages_1.SystemMessage(`历史对话摘要：\n\n${state.contextSummary}`);
+            modelMessages = [
+                summaryMsg,
+                ...modelMessages.slice(state.lastCompressedIndex),
+            ];
+        }
+        // simplify tool messages
+        modelMessages = simplifyToolMessages(modelMessages);
+        // keep recent 300 items
+        modelMessages = modelMessages.slice(0, 300);
+        const messages = [new messages_1.SystemMessage(prompt_1.systemPrompt), ...modelMessages];
+        const response = await modelWithTheseTools.invoke(messages, config);
+        return { messages: [response] };
+    }
+    async function toolNode(state, config) {
+        const messages = state.messages;
+        const toolMessageIds = new Set(messages
+            .filter((msg) => msg.type === 'tool')
+            .map((msg) => msg.tool_call_id));
+        let aiMessage;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages_1.AIMessage.isInstance(messages[i])) {
+                aiMessage = messages[i];
+                break;
+            }
+        }
+        if (!aiMessage || !messages_1.AIMessage.isInstance(aiMessage)) {
+            throw new Error('ToolNode only accepts AIMessages as input.');
+        }
+        const toolCalls = aiMessage.tool_calls?.filter((call) => call.id == null || !toolMessageIds.has(call.id)) ?? [];
+        if (toolCalls.length === 0) {
+            return { messages: [] };
+        }
+        const allowCalls = [];
+        const blockMessages = [];
+        const confirmCalls = [];
+        for (const call of toolCalls) {
+            const tool = toolList.find((t) => t.name === call.name);
+            const level = tool?.permission_level;
+            let decision;
+            if (level === 'read') {
+                decision = (0, read_1.checkReadPermission)(call);
+            }
+            else if (level === 'write') {
+                decision = (0, write_1.checkWritePermission)(call);
+            }
+            else if (level === 'exec') {
+                decision = (0, exec_1.checkExecPermission)(call);
+            }
+            else if (level === 'network') {
+                decision = (0, network_1.checkNetworkPermission)(call);
+            }
+            else if (level === 'mcp') {
+                decision = { action: 'confirm' };
+            }
+            else {
+                decision = { action: 'allow' };
+            }
+            if (decision.action === 'allow') {
+                allowCalls.push(call);
+            }
+            else if (decision.action === 'block') {
+                blockMessages.push(new messages_1.ToolMessage({
+                    content: decision.reason,
+                    tool_call_id: call.id ?? '',
+                    name: call.name,
+                }));
+            }
+            else {
+                confirmCalls.push(call);
+            }
+        }
+        async function executeCalls(calls) {
+            return Promise.all(calls.map(async (call) => {
+                const tool = toolList.find((t) => t.name === call.name);
+                console.log((0, colors_1.formatToolLog)(call.name, JSON.stringify(call.args)));
+                try {
+                    const threadId = config?.configurable?.thread_id || '';
+                    // PreToolUse hook
+                    const preResult = await (0, hooks_1.runPreToolUseHooks)({
+                        toolName: call.name,
+                        toolArgs: call.args,
+                        toolCallId: call.id ?? '',
+                        threadId,
+                    });
+                    if (preResult.action === 'block') {
+                        return new messages_1.ToolMessage({
+                            content: preResult.reason,
+                            tool_call_id: call.id ?? '',
+                            name: call.name,
+                        });
+                    }
+                    if (!tool)
+                        throw new Error(`Tool "${call.name}" not found.`);
+                    const output = await tool.invoke({ ...call, type: 'tool_call' }, config);
+                    let content = typeof output === 'string' ? output : JSON.stringify(output);
+                    // PostToolUse hook
+                    const postResult = await (0, hooks_1.runPostToolUseHooks)({
+                        toolName: call.name,
+                        toolArgs: call.args,
+                        toolOutput: content,
+                        toolCallId: call.id ?? '',
+                        threadId,
+                    });
+                    if (postResult.action === 'block') {
+                        content = postResult.reason;
+                    }
+                    else if (postResult.action === 'inject') {
+                        content = `[Hook injection]\n${postResult.message}\n\n${content}`;
+                    }
+                    if (preResult.action === 'inject') {
+                        content = `[Hook injection]\n${preResult.message}\n\n${content}`;
+                    }
+                    const finalContent = await (0, tools_1.maybePersistedOutput)(content, call.id ?? '');
+                    return new messages_1.ToolMessage({
+                        content: finalContent,
+                        tool_call_id: call.id ?? '',
+                        name: call.name,
+                    });
+                }
+                catch (e) {
+                    return new messages_1.ToolMessage({
+                        content: `Error: ${e.message}\n Please fix your mistakes.`,
+                        tool_call_id: call.id ?? '',
+                        name: call.name,
+                    });
+                }
+            }));
+        }
+        const allowOutputs = await executeCalls(allowCalls);
+        if (confirmCalls.length === 0) {
+            return { messages: [...allowOutputs, ...blockMessages] };
+        }
+        const result = (0, langgraph_1.interrupt)({ toolCalls: confirmCalls });
+        if (result !== 'approved') {
+            const deniedMessages = confirmCalls.map((call) => new messages_1.ToolMessage({
+                content: 'Tool execution was denied by the user.',
+                tool_call_id: call.id ?? '',
+                name: call.name,
+            }));
+            return {
+                messages: [...allowOutputs, ...blockMessages, ...deniedMessages],
+            };
+        }
+        const confirmOutputs = await executeCalls(confirmCalls);
+        return { messages: [...allowOutputs, ...blockMessages, ...confirmOutputs] };
+    }
+    const workflow = new langgraph_1.StateGraph(StateAnnotation)
+        .addNode('model_request', modelRequest)
+        .addNode('tools', toolNode)
+        .addEdge(langgraph_1.START, 'model_request')
+        .addConditionalEdges('model_request', shouldContinue, {
+        tools: 'tools',
+        [langgraph_1.END]: langgraph_1.END,
+    })
+        .addEdge('tools', 'model_request');
+    return workflow.compile({
+        checkpointer,
+    });
+}
+// ── Agent 创建 ────────────────────────────────────────────
+let agent = null;
+let subAgent = null;
+async function initAgent() {
+    await (0, tools_1.initTools)();
+    agent = createAgentGraph(tools_1.tools);
+    subAgent = createAgentGraph(tools_1.tools.filter((t) => t.name !== 'agent_tool'));
+}
+function getAgent() {
+    if (!agent)
+        throw new Error('Agent not initialized. Call initAgent() first.');
+    return agent;
+}
+function getSubAgent() {
+    if (!subAgent)
+        throw new Error('Agent not initialized. Call initAgent() first.');
+    return subAgent;
+}
+// ── 核心运行逻辑 ──────────────────────────────────────────
+async function _runAgent(compiledAgent, userMessage, onToken, onToolConfirmation, threadId, signal) {
+    const config = { configurable: { thread_id: threadId } };
+    let fullResponse = '';
+    let usageMetadata;
+    let input = { messages: [new messages_1.HumanMessage(userMessage)] };
+    while (true) {
+        const stream = await compiledAgent.stream(input, {
+            ...config,
+            streamMode: 'messages',
+            signal,
+        });
+        for await (const chunk of stream) {
+            if (signal?.aborted) {
+                throw new Error('abort');
+            }
+            const message = chunk[0];
+            const metadata = chunk[1];
+            if (metadata?.langgraph_node !== 'model_request')
+                continue;
+            const msgUsage = message.usage_metadata;
+            if (msgUsage) {
+                usageMetadata = msgUsage;
+            }
+            // AIMessageChunk 的 content 在 message.content 属性上，不在 kwargs.content
+            const content = message.content ?? message.kwargs?.content ?? '';
+            const toolCallChunks = message.tool_call_chunks ?? [];
+            if (!content || toolCallChunks.length > 0)
+                continue;
+            onToken(content);
+            fullResponse += content;
+        }
+        const state = await compiledAgent.getState(config);
+        const interruptedTask = state.tasks?.find((t) => t.interrupts?.length > 0);
+        if (!interruptedTask)
+            break;
+        const confirmed = await onToolConfirmation(interruptedTask.interrupts[0].value.toolCalls);
+        input = new langgraph_1.Command({ resume: confirmed ? 'approved' : 'denied' });
+    }
+    return { response: fullResponse, usageMetadata };
+}
+/**
+ * 以流式方式运行 agent，将 token 逐个回调给调用方
+ * @param {string} userMessage - 当前用户输入（历史已由 checkpointer 自动续接）
+ * @param {Function} onToken   - 每个 token 到来时的回调 (token: string) => void
+ * @param {Function} onToolConfirmation - tool 调用前的确认回调，返回 true 则执行，false 则拒绝
+ * @param {string} threadId    - 会话 ID，相同 ID 自动续上历史记录
+ * @returns {Promise<{ response: string; usageMetadata?: UsageMetadata }>}  完整的 AI 回复文本及 token 使用信息
+ */
+async function runAgentStream(userMessage, onToken, onToolConfirmation, threadId = 'default-session', signal) {
+    return _runAgent(getAgent(), userMessage, onToken, onToolConfirmation, threadId, signal);
+}
+/**
+ * 启动一个 subagent 执行独立任务，完成后返回结果
+ * @param {string} prompt - 给 subagent 的任务提示
+ * @returns {Promise<string>} subagent 的最终回复
+ */
+async function runSubAgent(prompt) {
+    const threadId = `subagent-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    const result = await _runAgent(getSubAgent(), prompt.trim(), () => { }, // 不需要流式输出
+    async () => true, // subagent 自动确认 tools
+    threadId, undefined);
+    return result.response;
+}
+async function compressContext(threadId) {
+    const config = { configurable: { thread_id: threadId } };
+    const currentState = await getAgent().getState(config);
+    const messages = currentState.values.messages || [];
+    const existingSummary = currentState.values.contextSummary || null;
+    const lastIndex = currentState.values.lastCompressedIndex || 0;
+    const count = currentState.values.compressionCount || 0;
+    const recentKeep = 6;
+    if (messages.length <= recentKeep + lastIndex) {
+        return { didCompress: false, count };
+    }
+    const toCompress = messages.slice(lastIndex, messages.length - recentKeep);
+    const newSummary = await (0, context_1.compressMessages)(toCompress, existingSummary);
+    await getAgent().updateState(config, {
+        contextSummary: newSummary,
+        lastCompressedIndex: messages.length - recentKeep,
+        compressionCount: count + 1,
+    });
+    return { didCompress: true, count: count + 1 };
+}

package/dist/agent/cli.d.ts

@@ -0,0 +1 @@
+export declare function interactiveChat(): Promise<void>;