@code4bug/jarvis-agent 1.1.4 → 1.1.6

package/README.md

@@ -11,6 +11,10 @@
 
 在终端中与 AI 对话，支持多轮推理、工具调用、流式输出，开箱即用。
 
+> 多智能体，不只是多几个助手，而是让需求分析、方案设计、编码实现、测试验证、代码评审等角色真正协同起来。  
+> 它可以用于多人协作流程构建、跨角色任务接力、复杂项目拆解与推进，也可以用于产品研发、缺陷修复、自动化交付等高频场景。  
+> 当多个智能体围绕同一目标持续沟通、分工与汇总时，AI 才真正从“单点应答”走向“团队作战”。
+
 ---
 
 ## 为什么叫 Jarvis

package/dist/cli.js

@@ -1,9 +1,22 @@
 #!/usr/bin/env node
 import { APP_VERSION } from './config/constants.js';
+import { ensureLoggerReady, logError, logInfo } from './core/logger.js';
 import { startJarvis } from './index.js';
 const arg = process.argv[2];
+ensureLoggerReady();
+logInfo('cli.launch', {
+    argv: process.argv.slice(2),
+    version: APP_VERSION,
+});
 if (arg === '--version' || arg === '-v' || arg === 'version') {
+    logInfo('cli.version', { version: APP_VERSION });
     console.log(APP_VERSION);
     process.exit(0);
 }
+process.on('uncaughtException', (error) => {
+    logError('process.uncaught_exception', error);
+});
+process.on('unhandledRejection', (reason) => {
+    logError('process.unhandled_rejection', reason);
+});
 startJarvis();

package/dist/config/constants.d.ts

@@ -3,7 +3,9 @@ export declare const APP_VERSION: string;
 export declare const PROJECT_NAME: string;
 /** Agentic Loop 最大迭代次数 */
 export declare const MAX_ITERATIONS = 50;
+export declare const JARVIS_HOME_DIR: string;
 export declare const SESSIONS_DIR: string;
+export declare const LOGS_DIR: string;
 /** 输入后是否隐藏 WelcomeHeader，默认 false（不隐藏） */
 export declare const HIDE_WELCOME_AFTER_INPUT = false;
 export declare const MODEL_NAME: string;

package/dist/config/constants.js

@@ -20,7 +20,9 @@ export const PROJECT_NAME = path.basename(process.cwd());
 export const MAX_ITERATIONS = 50;
 /** 会话存储目录（~/.jarvis/sessions/） */
 import os from 'os';
-export const SESSIONS_DIR = path.join(os.homedir(), '.jarvis', 'sessions');
+export const JARVIS_HOME_DIR = path.join(os.homedir(), '.jarvis');
+export const SESSIONS_DIR = path.join(JARVIS_HOME_DIR, 'sessions');
+export const LOGS_DIR = path.join(JARVIS_HOME_DIR, 'logs');
 /** 输入后是否隐藏 WelcomeHeader，默认 false（不隐藏） */
 export const HIDE_WELCOME_AFTER_INPUT = false;
 /** 从配置文件获取当前模型名称 */

package/dist/config/memory.d.ts

@@ -0,0 +1,7 @@
+export declare const MEMORY_FILE_PATH: string;
+export declare function ensureMemoryHomeDir(): string;
+export declare function ensureMemoryFile(): string;
+export declare function readPersistentMemory(): string;
+export declare function readPersistentMemoryForPrompt(maxChars?: number): string;
+export declare function appendPersistentMemory(content: string): void;
+export declare function replacePersistentMemory(content: string): void;

package/dist/config/memory.js

@@ -0,0 +1,55 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+export const MEMORY_FILE_PATH = path.join(os.homedir(), '.jarvis', 'MEMORY.md');
+const MEMORY_FILE_HEADER = [
+    '# Jarvis 长期记忆',
+    '',
+    '> 这里沉淀可复用的经验、技能、偏好、约束与稳定环境事实。',
+    '> 避免写入一次性闲聊、临时输出、密钥或其它敏感信息。',
+    '',
+].join('\n');
+export function ensureMemoryHomeDir() {
+    const dir = path.dirname(MEMORY_FILE_PATH);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+export function ensureMemoryFile() {
+    ensureMemoryHomeDir();
+    if (!fs.existsSync(MEMORY_FILE_PATH)) {
+        fs.writeFileSync(MEMORY_FILE_PATH, MEMORY_FILE_HEADER, 'utf-8');
+    }
+    return MEMORY_FILE_PATH;
+}
+export function readPersistentMemory() {
+    try {
+        ensureMemoryFile();
+        return fs.readFileSync(MEMORY_FILE_PATH, 'utf-8').trim();
+    }
+    catch {
+        return '';
+    }
+}
+export function readPersistentMemoryForPrompt(maxChars = 12000) {
+    const content = readPersistentMemory();
+    if (!content)
+        return '';
+    if (content.length <= maxChars)
+        return content;
+    return `...[已截断，仅保留最近 ${maxChars} 字符]\n${content.slice(-maxChars)}`;
+}
+export function appendPersistentMemory(content) {
+    const normalized = content.trim();
+    if (!normalized)
+        return;
+    ensureMemoryFile();
+    const current = fs.readFileSync(MEMORY_FILE_PATH, 'utf-8');
+    const suffix = current.endsWith('\n\n') ? '' : (current.endsWith('\n') ? '\n' : '\n\n');
+    fs.appendFileSync(MEMORY_FILE_PATH, `${suffix}${normalized}\n`, 'utf-8');
+}
+export function replacePersistentMemory(content) {
+    ensureMemoryFile();
+    fs.writeFileSync(MEMORY_FILE_PATH, `${content.trimEnd()}\n`, 'utf-8');
+}

package/dist/config/userProfile.d.ts

@@ -0,0 +1,4 @@
+export declare const USER_PROFILE_PATH: string;
+export declare function ensureJarvisHomeDir(): string;
+export declare function readUserProfile(): string;
+export declare function writeUserProfile(content: string): void;

package/dist/config/userProfile.js

@@ -0,0 +1,25 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+export const USER_PROFILE_PATH = path.join(os.homedir(), '.jarvis', 'USER.md');
+export function ensureJarvisHomeDir() {
+    const dir = path.dirname(USER_PROFILE_PATH);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+export function readUserProfile() {
+    try {
+        if (!fs.existsSync(USER_PROFILE_PATH))
+            return '';
+        return fs.readFileSync(USER_PROFILE_PATH, 'utf-8').trim();
+    }
+    catch {
+        return '';
+    }
+}
+export function writeUserProfile(content) {
+    ensureJarvisHomeDir();
+    fs.writeFileSync(USER_PROFILE_PATH, content.trimEnd() + '\n', 'utf-8');
+}

package/dist/core/AgentMessageBus.d.ts

@@ -1,16 +1,3 @@
-/**
- * AgentMessageBus — SubAgent 间通讯总线（进程内单例）
- *
- * 提供发布/订阅机制，允许：
- *   - SubAgent 向命名频道发布消息
- *   - SubAgent 订阅频道，等待其他 Agent 发布的消息
- *   - 主 Agent 观察所有频道历史
- *
- * 线程安全说明：
- *   Node.js Worker 线程之间不共享内存，因此 MessageBus 运行在
- *   主线程（queryWorker）中，SubAgent Worker 通过 IPC 消息与其交互。
- *   SubAgentBridge 负责在主线程侧代理 publish/subscribe 请求。
- */
 export interface BusMessage {
     /** 发布者 Agent 标识 */
     from: string;

package/dist/core/AgentMessageBus.js

@@ -11,6 +11,7 @@
  *   主线程（queryWorker）中，SubAgent Worker 通过 IPC 消息与其交互。
  *   SubAgentBridge 负责在主线程侧代理 publish/subscribe 请求。
  */
+import { logInfo } from './logger.js';
 class AgentMessageBus {
     /** 频道历史消息，key = channel */
     history = new Map();
@@ -24,6 +25,11 @@ class AgentMessageBus {
      */
     publish(from, channel, payload) {
         const msg = { from, channel, payload, timestamp: Date.now() };
+        logInfo('bus.publish', {
+            from,
+            channel,
+            payloadLength: payload.length,
+        });
         // 存入历史
         if (!this.history.has(channel))
             this.history.set(channel, []);
@@ -48,10 +54,19 @@ class AgentMessageBus {
      * @param fromOffset 从第几条开始消费（0-based），不传则只等新消息
      */
     subscribe(channel, timeoutMs = 30_000, fromOffset) {
+        logInfo('bus.subscribe', {
+            channel,
+            timeoutMs,
+            fromOffset,
+        });
         // 如果指定了 offset 且历史中已有该位置之后的消息，立即返回
         if (fromOffset !== undefined) {
             const history = this.history.get(channel) ?? [];
             if (fromOffset < history.length) {
+                logInfo('bus.subscribe.hit_history', {
+                    channel,
+                    fromOffset,
+                });
                 return Promise.resolve(history[fromOffset]);
             }
         }
@@ -62,10 +77,16 @@ class AgentMessageBus {
                 if (list) {
                     this.waiters.set(channel, list.filter((w) => w.resolve !== resolve));
                 }
+                logInfo('bus.subscribe.timeout', { channel, timeoutMs, fromOffset });
                 resolve(null);
             }, timeoutMs);
             const wrappedResolve = (msg) => {
                 clearTimeout(timer);
+                logInfo('bus.subscribe.received', {
+                    channel,
+                    fromOffset,
+                    from: msg.from,
+                });
                 resolve(msg);
             };
             if (!this.waiters.has(channel))

package/dist/core/QueryEngine.d.ts

@@ -20,11 +20,13 @@ export declare class QueryEngine {
     private session;
     private transcript;
     private workerBridge;
+    private memoryUpdateQueue;
     constructor();
     /** 注册持久 UI 回调，供后台 spawn_agent 子 Agent 推送消息 */
     registerUIBus(onMessage: (msg: Message) => void, onUpdateMessage: (id: string, updates: Partial<Message>) => void): void;
     private createSession;
     private ensureSessionDir;
+    private createService;
     /** 处理用户输入（在独立 Worker 线程中执行） */
     handleQuery(userInput: string, callbacks: EngineCallbacks): Promise<void>;
     /** 终止当前任务（通知 Worker 中断） */
@@ -37,6 +39,7 @@ export declare class QueryEngine {
     switchAgent(agentName: string): void;
     /** 保存会话到文件 */
     private saveSession;
+    private schedulePersistentMemoryUpdate;
     /** 列出所有历史会话（按更新时间倒序），返回摘要信息 */
     static listSessions(): {
         id: string;

package/dist/core/QueryEngine.js

@@ -9,32 +9,28 @@ import { SESSIONS_DIR } from '../config/constants.js';
 import { setActiveAgent } from '../config/agentState.js';
 import { clearAuthorizations } from './safeguard.js';
 import { agentUIBus } from './AgentRegistry.js';
+import { logError, logInfo, logWarn } from './logger.js';
+import { updateUserProfileFromInput } from '../services/userProfile.js';
+import { updatePersistentMemoryFromConversation } from '../services/persistentMemory.js';
 export class QueryEngine {
     service;
     session;
     transcript = [];
     workerBridge = new WorkerBridge();
+    memoryUpdateQueue = Promise.resolve();
     constructor() {
-        // 尝试从配置文件加载 LLM，失败则回退 MockService
-        const config = loadConfig();
-        const activeModel = getActiveModel(config);
-        if (activeModel) {
-            try {
-                this.service = new LLMServiceImpl();
-            }
-            catch {
-                this.service = new MockService();
-            }
-        }
-        else {
-            this.service = new MockService();
-        }
+        this.service = this.createService();
         this.session = this.createSession();
         this.ensureSessionDir();
+        logInfo('engine.created', {
+            sessionId: this.session.id,
+            service: this.service.constructor.name,
+        });
     }
     /** 注册持久 UI 回调，供后台 spawn_agent 子 Agent 推送消息 */
     registerUIBus(onMessage, onUpdateMessage) {
         agentUIBus.register(onMessage, onUpdateMessage);
+        logInfo('engine.ui_bus_registered', { sessionId: this.session.id });
     }
     createSession() {
         return {
@@ -51,8 +47,27 @@ export class QueryEngine {
             fs.mkdirSync(SESSIONS_DIR, { recursive: true });
         }
     }
+    createService() {
+        const config = loadConfig();
+        const activeModel = getActiveModel(config);
+        if (activeModel) {
+            try {
+                return new LLMServiceImpl();
+            }
+            catch {
+                return new MockService();
+            }
+        }
+        return new MockService();
+    }
     /** 处理用户输入（在独立 Worker 线程中执行） */
     async handleQuery(userInput, callbacks) {
+        const previousTranscriptLength = this.transcript.length;
+        logInfo('query.received', {
+            sessionId: this.session.id,
+            inputLength: userInput.length,
+            preview: userInput.slice(0, 200),
+        });
         const userMsg = {
             id: uuid(),
             type: 'user',
@@ -62,6 +77,12 @@ export class QueryEngine {
         };
         callbacks.onMessage(userMsg);
         this.session.messages.push(userMsg);
+        if (this.transcript.length === 0) {
+            const updated = await updateUserProfileFromInput(userInput);
+            if (updated) {
+                this.service = this.createService();
+            }
+        }
         // 将回调包装后传给 WorkerBridge，Worker 事件会映射回这里
         const bridgeCallbacks = {
             onMessage: (msg) => {
@@ -87,8 +108,16 @@ export class QueryEngine {
         };
         try {
             this.transcript = await this.workerBridge.run(userInput, this.transcript, bridgeCallbacks);
+            const recentTranscript = this.transcript.slice(previousTranscriptLength);
+            this.schedulePersistentMemoryUpdate(userInput, recentTranscript);
+            logInfo('query.completed', {
+                sessionId: this.session.id,
+                transcriptLength: this.transcript.length,
+                totalTokens: this.session.totalTokens,
+            });
         }
         catch (err) {
+            logError('query.failed', err, { sessionId: this.session.id });
             const errMsg = {
                 id: uuid(),
                 type: 'error',
@@ -104,38 +133,39 @@ export class QueryEngine {
     }
     /** 终止当前任务（通知 Worker 中断） */
     abort() {
+        logWarn('query.abort_requested', { sessionId: this.session.id });
         this.workerBridge.abort();
     }
     /** 重置会话 */
     reset() {
+        logInfo('session.reset', { sessionId: this.session.id });
         this.saveSession();
         this.session = this.createSession();
         this.transcript = [];
+        this.memoryUpdateQueue = Promise.resolve();
         clearAuthorizations();
     }
     /**
      * 切换智能体：持久化选择 + 重建 LLM service + 重置会话
      */
     switchAgent(agentName) {
+        logInfo('agent.switch.start', {
+            fromSessionId: this.session.id,
+            agentName,
+        });
         setActiveAgent(agentName);
         // 重建 LLM service 以加载新 agent 的 system prompt
-        const config = loadConfig();
-        const activeModel = getActiveModel(config);
-        if (activeModel) {
-            try {
-                this.service = new LLMServiceImpl();
-            }
-            catch {
-                this.service = new MockService();
-            }
-        }
-        else {
-            this.service = new MockService();
-        }
+        this.service = this.createService();
         // 重置会话上下文
         this.saveSession();
         this.session = this.createSession();
         this.transcript = [];
+        this.memoryUpdateQueue = Promise.resolve();
+        logInfo('agent.switch.completed', {
+            sessionId: this.session.id,
+            agentName,
+            service: this.service.constructor.name,
+        });
     }
     /** 保存会话到文件 */
     saveSession() {
@@ -149,8 +179,29 @@ export class QueryEngine {
             }
             const filePath = path.join(SESSIONS_DIR, `${this.session.id}.json`);
             fs.writeFileSync(filePath, JSON.stringify(this.session, null, 2), 'utf-8');
+            logInfo('session.saved', {
+                sessionId: this.session.id,
+                filePath,
+                messageCount: this.session.messages.length,
+            });
         }
-        catch { /* 静默失败 */ }
+        catch (error) {
+            logError('session.save_failed', error, { sessionId: this.session.id });
+        }
+    }
+    schedulePersistentMemoryUpdate(userInput, recentTranscript) {
+        if (!userInput.trim() || recentTranscript.length === 0)
+            return;
+        const sessionId = this.session.id;
+        this.memoryUpdateQueue = this.memoryUpdateQueue
+            .catch(() => { })
+            .then(async () => {
+            await updatePersistentMemoryFromConversation({
+                sessionId,
+                userInput,
+                recentTranscript,
+            });
+        });
     }
     /** 列出所有历史会话（按更新时间倒序），返回摘要信息 */
     static listSessions() {
@@ -221,9 +272,15 @@ export class QueryEngine {
                     });
                 }
             }
+            logInfo('session.loaded', {
+                sessionId,
+                messageCount: cleanedMessages.length,
+                transcriptLength: this.transcript.length,
+            });
             return { session: this.session, messages: cleanedMessages };
         }
-        catch {
+        catch (error) {
+            logError('session.load_failed', error, { sessionId });
             return null;
         }
     }
@@ -250,9 +307,14 @@ export class QueryEngine {
                 }
                 catch { /* 跳过删除失败的文件 */ }
             }
+            logInfo('session.clear_others', {
+                sessionId: this.session.id,
+                removedCount: count,
+            });
             return count;
         }
-        catch {
+        catch (error) {
+            logError('session.clear_others_failed', error, { sessionId: this.session.id });
             return 0;
         }
     }

package/dist/core/SubAgentBridge.js

@@ -12,6 +12,7 @@ import { Worker } from 'worker_threads';
 import { fileURLToPath } from 'url';
 import path from 'path';
 import { agentMessageBus } from './AgentMessageBus.js';
+import { logError, logInfo, logWarn } from './logger.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 /** 创建 SubAgent Worker（兼容 tsx 开发模式与编译后 .js） */
@@ -42,6 +43,10 @@ export class SubAgentBridge {
         return new Promise((resolve, reject) => {
             const worker = createSubAgentWorker();
             this.worker = worker;
+            logInfo('subagent_bridge.run.start', {
+                taskId: task.taskId,
+                allowedTools: task.allowedTools,
+            });
             // 收集 SubAgent 产生的所有消息，用于汇总结果
             const collectedMessages = [];
             let finalTranscript = [];
@@ -125,6 +130,11 @@ export class SubAgentBridge {
                         finalTranscript = msg.transcript;
                         this.worker = null;
                         worker.terminate();
+                        logInfo('subagent_bridge.run.done', {
+                            taskId: msg.taskId,
+                            transcriptLength: msg.transcript.length,
+                            messageCount: collectedMessages.length,
+                        });
                         // 从 transcript 中提取最终输出文本
                         resolve({
                             taskId: msg.taskId,
@@ -137,6 +147,10 @@ export class SubAgentBridge {
                     case 'error':
                         this.worker = null;
                         worker.terminate();
+                        logError('subagent_bridge.run.failed', msg.message, {
+                            taskId: msg.taskId,
+                            messageCount: collectedMessages.length,
+                        });
                         resolve({
                             taskId: msg.taskId,
                             status: 'error',
@@ -150,12 +164,14 @@ export class SubAgentBridge {
             });
             worker.on('error', (err) => {
                 this.worker = null;
+                logError('subagent_bridge.worker_error', err, { taskId: task.taskId });
                 reject(err);
             });
             worker.on('exit', (code) => {
                 if (this.worker) {
                     // Worker 退出但未发送 done/error，说明异常终止
                     this.worker = null;
+                    logError('subagent_bridge.worker_exit_abnormal', undefined, { taskId: task.taskId, code });
                     reject(new Error(`SubAgent Worker 意外退出，code=${code}`));
                 }
             });
@@ -166,6 +182,7 @@ export class SubAgentBridge {
     /** 中断 SubAgent 执行 */
     abort() {
         if (this.worker) {
+            logWarn('subagent_bridge.abort_forwarded');
             const msg = { type: 'abort' };
             this.worker.postMessage(msg);
         }

package/dist/core/WorkerBridge.js

@@ -7,6 +7,7 @@ import { fileURLToPath } from 'url';
 import path from 'path';
 import { agentMessageBus } from './AgentMessageBus.js';
 import { spawnSubAgentInMainThread } from '../tools/spawnAgent.js';
+import { logError, logInfo, logWarn } from './logger.js';
 // 兼容 ESM __dirname
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -41,6 +42,10 @@ export class WorkerBridge {
             const workerTsPath = path.join(__dirname, 'queryWorker.ts');
             const worker = createWorker(workerTsPath);
             this.worker = worker;
+            logInfo('worker_bridge.run.start', {
+                inputLength: userInput.length,
+                transcriptLength: transcript.length,
+            });
             worker.on('message', async (msg) => {
                 switch (msg.type) {
                     case 'message':
@@ -143,22 +148,28 @@ export class WorkerBridge {
                     case 'done':
                         this.worker = null;
                         worker.terminate();
+                        logInfo('worker_bridge.run.done', {
+                            transcriptLength: msg.transcript.length,
+                        });
                         resolve(msg.transcript);
                         break;
                     case 'error':
                         this.worker = null;
                         worker.terminate();
+                        logError('worker_bridge.run.error', msg.message);
                         reject(new Error(msg.message));
                         break;
                 }
             });
             worker.on('error', (err) => {
                 this.worker = null;
+                logError('worker_bridge.worker_error', err);
                 reject(err);
             });
             worker.on('exit', (code) => {
                 if (code !== 0 && this.worker) {
                     this.worker = null;
+                    logError('worker_bridge.worker_exit_abnormal', undefined, { code });
                     reject(new Error(`Worker 异常退出，code=${code}`));
                 }
             });
@@ -170,6 +181,7 @@ export class WorkerBridge {
     /** 向 Worker 发送中断信号 */
     abort() {
         if (this.worker) {
+            logWarn('worker_bridge.abort_forwarded');
             const msg = { type: 'abort' };
             this.worker.postMessage(msg);
         }

package/dist/core/logger.d.ts

@@ -0,0 +1,8 @@
+export type LogLevel = 'INFO' | 'WARN' | 'ERROR';
+export interface LogPayload {
+    [key: string]: unknown;
+}
+export declare function ensureLoggerReady(): string;
+export declare function logInfo(event: string, payload?: LogPayload): void;
+export declare function logWarn(event: string, payload?: LogPayload): void;
+export declare function logError(event: string, error?: unknown, payload?: LogPayload): void;

package/dist/core/logger.js

@@ -0,0 +1,63 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { isMainThread, threadId } from 'worker_threads';
+function resolveLogsDir() {
+    return path.join(os.homedir(), '.jarvis', 'logs');
+}
+function ensureLogsDir() {
+    const logsDir = resolveLogsDir();
+    if (!fs.existsSync(logsDir)) {
+        fs.mkdirSync(logsDir, { recursive: true });
+    }
+    return logsDir;
+}
+function getLogFilePath(date = new Date()) {
+    const logsDir = ensureLogsDir();
+    const day = date.toISOString().slice(0, 10);
+    return path.join(logsDir, `${day}.log`);
+}
+function normalizeError(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+        };
+    }
+    return { message: String(error) };
+}
+function writeLog(level, event, payload = {}) {
+    try {
+        const now = new Date();
+        const line = JSON.stringify({
+            timestamp: now.toISOString(),
+            level,
+            event,
+            pid: process.pid,
+            threadId,
+            workerType: isMainThread ? 'main' : 'worker',
+            cwd: process.cwd(),
+            ...payload,
+        });
+        fs.appendFileSync(getLogFilePath(now), `${line}\n`, 'utf-8');
+    }
+    catch {
+        // 日志系统自身不能影响主流程
+    }
+}
+export function ensureLoggerReady() {
+    return ensureLogsDir();
+}
+export function logInfo(event, payload) {
+    writeLog('INFO', event, payload);
+}
+export function logWarn(event, payload) {
+    writeLog('WARN', event, payload);
+}
+export function logError(event, error, payload = {}) {
+    writeLog('ERROR', event, {
+        ...payload,
+        ...(error !== undefined ? { error: normalizeError(error) } : {}),
+    });
+}