zhitalk 0.0.12 → 0.1.0

package/dist/agent/agent.js

@@ -6,7 +6,8 @@ import { DB_PATH } from './db.js';
 import { tools, maybePersistedOutput, initTools } from './tools.js';
 import { compressMessages } from './context.js';
 import { systemPrompt } from './prompt.js';
-import { formatToolLog } from './colors.js';
+import { formatToolLog, formatTodoList } from './colors.js';
+import { processTodoCalls, formatTodoListForPrompt } from './todo.js';
 import { checkReadPermission } from './permission/read.js';
 import { checkWritePermission } from './permission/write.js';
 import { checkExecPermission } from './permission/exec.js';
@@ -33,6 +34,10 @@ const StateAnnotation = Annotation.Root({
         reducer: (_prev, next) => next,
         default: () => 0,
     }),
+    todoList: Annotation({
+        reducer: (_prev, next) => next,
+        default: () => null,
+    }),
 });
 // ── Graph Nodes ───────────────────────────────────────────
 function shouldContinue(state) {
@@ -121,7 +126,11 @@ function createAgentGraph(toolList) {
             }
             return true;
         });
-        const messages = [new SystemMessage(systemPrompt), ...modelMessages];
+        const messages = [new SystemMessage(systemPrompt)];
+        if (state.todoList && state.todoList.length > 0) {
+            messages.push(new SystemMessage(`当前任务进度：\n${formatTodoListForPrompt(state.todoList)}`));
+        }
+        messages.push(...modelMessages);
         const response = await modelWithTheseTools.invoke(messages, config);
         return { messages: [response] };
     }
@@ -240,9 +249,25 @@ function createAgentGraph(toolList) {
                 }
             }));
         }
-        const allowOutputs = await executeCalls(allowCalls);
+        // 分离 todo 工具调用
+        const regularAllowCalls = [];
+        const todoAllowCalls = [];
+        for (const call of allowCalls) {
+            if (call.name === 'create_todo_list' || call.name === 'update_todo_status') {
+                todoAllowCalls.push(call);
+            }
+            else {
+                regularAllowCalls.push(call);
+            }
+        }
+        const regularOutputs = await executeCalls(regularAllowCalls);
+        const todoResult = processTodoCalls(todoAllowCalls, state.todoList);
+        if (todoResult.todoList && todoResult.todoList.length > 0) {
+            console.log(formatTodoList(todoResult.todoList));
+        }
+        const allowOutputs = [...regularOutputs, ...todoResult.messages];
         if (confirmCalls.length === 0) {
-            return { messages: [...allowOutputs, ...blockMessages] };
+            return { messages: [...allowOutputs, ...blockMessages], todoList: todoResult.todoList };
         }
         const result = interrupt({ toolCalls: confirmCalls });
         if (result !== 'approved') {
@@ -253,10 +278,11 @@ function createAgentGraph(toolList) {
             }));
             return {
                 messages: [...allowOutputs, ...blockMessages, ...deniedMessages],
+                todoList: todoResult.todoList,
             };
         }
         const confirmOutputs = await executeCalls(confirmCalls);
-        return { messages: [...allowOutputs, ...blockMessages, ...confirmOutputs] };
+        return { messages: [...allowOutputs, ...blockMessages, ...confirmOutputs], todoList: todoResult.todoList };
     }
     const workflow = new StateGraph(StateAnnotation)
         .addNode('model_request', modelRequest)

package/dist/agent/colors.d.ts

@@ -15,5 +15,11 @@ export declare const color: {
     warn: (text: string) => string;
     info: (text: string) => string;
     good: (text: string) => string;
+    todoTag: () => string;
 };
+export interface TodoDisplayItem {
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'failed';
+}
+export declare function formatTodoList(items: TodoDisplayItem[]): string;
 export declare function formatToolLog(name: string, detail?: string): string;

package/dist/agent/colors.js

@@ -33,7 +33,25 @@ export const color = {
     warn: (text) => ck().yellow(text),
     info: (text) => ck().blueBright(text),
     good: (text) => ck().greenBright(text),
+    todoTag: () => ck().magentaBright('[Todo]'),
 };
+export function formatTodoList(items) {
+    const lines = [color.todoTag()];
+    for (const item of items) {
+        const symbol = item.status === 'completed'
+            ? color.good('✓')
+            : item.status === 'in_progress'
+                ? color.info('→')
+                : item.status === 'failed'
+                    ? color.error('✗')
+                    : color.gray('○');
+        const desc = item.status === 'completed' || item.status === 'failed'
+            ? color.gray(item.content)
+            : item.content;
+        lines.push(`  ${symbol} ${desc}`);
+    }
+    return '\n' + lines.join('\n') + '\n';
+}
 export function formatToolLog(name, detail) {
     const parts = [color.toolTag(), color.toolName(name), color.toolAction()];
     if (detail) {

package/dist/agent/prompt.js

@@ -47,12 +47,22 @@ ${skillsText}`
 const skillPrompt = `## Skills
 
 ${skillList}\n\nNote: If you want to add a new skill, it must be placed in the ${path.join(WORKSPACE_DIR, 'skills')} directory.`;
+const todoPrompt = `## Task Planning
+
+When a user's request is a complex, multi-step task (such as data analysis, writing a document, planning a task, or any task clearly requiring more than 3 steps), you MUST:
+1. First call \`create_todo_list\` to create a structured plan with clear, actionable steps
+2. Then execute each step one by one
+3. After completing each step, call \`update_todo_status\` to mark it as completed (or failed if it didn't work)
+4. Only provide the final answer after all steps are done
+
+For simple, single-step tasks, do NOT use the todo list tools.`;
 export const systemPrompt = [
     basePrompt,
     profilePrompt,
     memoryPrompt,
     skillPrompt,
     dateTimePrompt,
+    todoPrompt,
 ]
     .filter(Boolean)
     .join('\n\n');

package/dist/agent/todo.d.ts

@@ -0,0 +1,17 @@
+import { ToolMessage } from '@langchain/core/messages';
+export interface TodoItem {
+    id: number;
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'failed';
+}
+interface TodoCall {
+    id?: string;
+    name: string;
+    args: Record<string, any>;
+}
+export declare function processTodoCalls(calls: TodoCall[], currentTodoList: TodoItem[] | null): {
+    messages: ToolMessage[];
+    todoList: TodoItem[] | null;
+};
+export declare function formatTodoListForPrompt(items: TodoItem[]): string;
+export {};

package/dist/agent/todo.js

@@ -0,0 +1,86 @@
+import { ToolMessage } from '@langchain/core/messages';
+export function processTodoCalls(calls, currentTodoList) {
+    const messages = [];
+    let todoList = currentTodoList;
+    for (const call of calls) {
+        if (call.name === 'create_todo_list') {
+            const items = call.args.items;
+            if (!Array.isArray(items) || items.length === 0) {
+                messages.push(new ToolMessage({
+                    content: 'Error: items must be a non-empty array.',
+                    tool_call_id: call.id ?? '',
+                    name: call.name,
+                }));
+                continue;
+            }
+            todoList = items.map((content, i) => ({
+                id: i,
+                content: typeof content === 'string' ? content.trim() : String(content),
+                status: 'pending',
+            }));
+            messages.push(new ToolMessage({
+                content: 'Todo list created successfully.',
+                tool_call_id: call.id ?? '',
+                name: call.name,
+            }));
+        }
+        else if (call.name === 'update_todo_status') {
+            const index = call.args.index;
+            const status = call.args.status;
+            if (!todoList) {
+                messages.push(new ToolMessage({
+                    content: 'Error: no todo list exists.',
+                    tool_call_id: call.id ?? '',
+                    name: call.name,
+                }));
+                continue;
+            }
+            if (typeof index !== 'number' ||
+                !Number.isInteger(index) ||
+                index < 0 ||
+                index >= todoList.length) {
+                messages.push(new ToolMessage({
+                    content: `Error: index ${index} is out of range.`,
+                    tool_call_id: call.id ?? '',
+                    name: call.name,
+                }));
+                continue;
+            }
+            const validStatuses = [
+                'pending',
+                'in_progress',
+                'completed',
+                'failed',
+            ];
+            if (!validStatuses.includes(status)) {
+                messages.push(new ToolMessage({
+                    content: `Error: invalid status "${status}".`,
+                    tool_call_id: call.id ?? '',
+                    name: call.name,
+                }));
+                continue;
+            }
+            todoList[index].status = status;
+            messages.push(new ToolMessage({
+                content: `Todo item ${index} updated to ${status}.`,
+                tool_call_id: call.id ?? '',
+                name: call.name,
+            }));
+        }
+    }
+    return { messages, todoList };
+}
+export function formatTodoListForPrompt(items) {
+    return items
+        .map((item) => {
+        const statusMark = item.status === 'completed'
+            ? '[x]'
+            : item.status === 'in_progress'
+                ? '[~]'
+                : item.status === 'failed'
+                    ? '[!]'
+                    : '[ ]';
+        return `${statusMark} ${item.content}`;
+    })
+        .join('\n');
+}

package/dist/agent/tools.js

@@ -145,6 +145,35 @@ const agentTool = createZhitalkTool(agentToolImpl, {
             .describe('A clear, self-contained task prompt for the sub-agent. It should include all necessary context because the sub-agent cannot see the current conversation history.'),
     }),
 }, 'exec');
+async function createTodoListDummy() {
+    return 'Error: create_todo_list should be handled internally by the agent.';
+}
+async function updateTodoStatusDummy() {
+    return 'Error: update_todo_status should be handled internally by the agent.';
+}
+const createTodoListTool = createZhitalkTool(createTodoListDummy, {
+    name: 'create_todo_list',
+    description: 'Create a structured todo list for a complex, multi-step task. Must be called BEFORE starting execution. Each item should be a clear, actionable step.',
+    schema: z.object({
+        items: z
+            .array(z.string().describe('A single todo item description.'))
+            .describe('The list of todo items to create. Each item should be a clear, actionable step.'),
+    }),
+}, 'read');
+const updateTodoStatusTool = createZhitalkTool(updateTodoStatusDummy, {
+    name: 'update_todo_status',
+    description: 'Update the status of a todo item in the current todo list. Call this after completing EACH step.',
+    schema: z.object({
+        index: z
+            .number()
+            .int()
+            .min(0)
+            .describe('The zero-based index of the todo item to update.'),
+        status: z
+            .enum(['in_progress', 'completed', 'failed'])
+            .describe('The new status of the todo item.'),
+    }),
+}, 'read');
 export async function maybePersistedOutput(content, toolCallId) {
     const MAX_LENGTH = 50000;
     if (content.length <= MAX_LENGTH) {
@@ -180,6 +209,8 @@ export const nativeTools = [
     memoryDeleteTool,
     profileUpdateTool,
     agentTool,
+    createTodoListTool,
+    updateTodoStatusTool,
 ];
 export let tools = [...nativeTools];
 export async function initTools() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zhitalk",
-  "version": "0.0.12",
+  "version": "0.1.0",
   "description": "A personal AI Agent like OpenClaw, including tools, skills, memory, hook, sub-agent, MCP server, etc. Run in the terminal.",
   "type": "module",
   "main": "dist/index.js",