nine-hundred 0.0.1

package/dist/agent/tools.js

@@ -0,0 +1,218 @@
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { agentTool as agentToolImpl, agentToolSchema } from './tools/agent_tool/index.js';
+import { execTool as execToolImpl } from './tools/exec_tool/index.js';
+import { loadSkillTool as loadSkillToolImpl } from './tools/load_skill_tool/index.js';
+import { readFileTool as readFileToolImpl } from './tools/read_file_tool/index.js';
+import { runJsTool as runJsToolImpl } from './tools/run_js_tool/index.js';
+import { runPyTool as runPyToolImpl } from './tools/run_py_tool/index.js';
+import { memoryCreateTool as memoryCreateToolImpl } from './tools/memory_create_tool/index.js';
+import { memoryDeleteTool as memoryDeleteToolImpl } from './tools/memory_delete_tool/index.js';
+import { memoryRetrieveTool as memoryRetrieveToolImpl } from './tools/memory_retrieve_tool/index.js';
+import { profileUpdateTool as profileUpdateToolImpl } from './tools/profile_update_tool/index.js';
+import { writeFileTool as writeFileToolImpl } from './tools/write_file_tool/index.js';
+import { webFetchUrl as webFetchUrlImpl } from './tools/web_fetch_url/index.js';
+import { webSearchTool as webSearchToolImpl } from './tools/web_search_tool/index.js';
+import { getMcpToolWrappers } from './mcp/index.js';
+export { registerSubagentRunner } from './tools/agent_tool/index.js';
+function create900Tool(impl, options) {
+    const t = tool(impl, {
+        name: options.name,
+        description: options.description,
+        schema: options.schema,
+    });
+    const wrapped = t;
+    wrapped.permission_level = options.permissionLevel;
+    return wrapped;
+}
+const loadSkillTool = create900Tool(async ({ skillName }) => loadSkillToolImpl(skillName), {
+    name: 'load_skill_tool',
+    description: 'Load the full SKILL.md for exactly one available skill by name.',
+    schema: z.object({
+        skillName: z.string().describe('Name of exactly one available skill to load.'),
+    }),
+    permissionLevel: 'read',
+});
+const readFileTool = create900Tool(async ({ filePath }) => readFileToolImpl(filePath), {
+    name: 'read_file_tool',
+    description: 'Read the contents of a UTF-8 text file.',
+    schema: z.object({
+        filePath: z.string().describe('Absolute or relative path to the local file to read.'),
+    }),
+    permissionLevel: 'read',
+});
+const writeFileTool = create900Tool(async ({ filePath, content }) => writeFileToolImpl(filePath, content), {
+    name: 'write_file_tool',
+    description: 'Create or overwrite a file. Will create parent directories if needed.',
+    schema: z.object({
+        filePath: z.string().describe('Absolute or relative path to the local file to write.'),
+        content: z.string().describe('UTF-8 text content to write to the file.'),
+    }),
+    permissionLevel: 'write',
+});
+const execTool = create900Tool(async ({ command, cwd }) => execToolImpl(command, cwd), {
+    name: 'exec_tool',
+    description: 'Execute a safe shell command inside the current working directory. Dangerous file operations are not allowed.',
+    schema: z.object({
+        command: z.string().describe('Shell command to execute.'),
+        cwd: z
+            .string()
+            .optional()
+            .describe('Optional working directory relative to the current working directory.'),
+    }),
+    permissionLevel: 'exec',
+});
+const runJsTool = create900Tool(async ({ code, cwd }) => runJsToolImpl(code, cwd), {
+    name: 'run_js_tool',
+    description: 'Execute JavaScript code with local Node.js and return stdout, stderr, or errors.',
+    schema: z.object({
+        code: z.string().describe('JavaScript code to execute with local Node.js.'),
+        cwd: z
+            .string()
+            .optional()
+            .describe('Optional working directory relative to the current working directory.'),
+    }),
+    permissionLevel: 'exec',
+});
+const runPyTool = create900Tool(async ({ code, cwd }) => runPyToolImpl(code, cwd), {
+    name: 'run_py_tool',
+    description: 'Execute Python code with local Python 3 and return stdout, stderr, or errors.',
+    schema: z.object({
+        code: z.string().describe('Python code to execute with local Python 3.'),
+        cwd: z
+            .string()
+            .optional()
+            .describe('Optional working directory relative to the current working directory.'),
+    }),
+    permissionLevel: 'exec',
+});
+const webFetchUrl = create900Tool(async ({ url }) => webFetchUrlImpl(url), {
+    name: 'web_fetch_url',
+    description: 'Fetch a web page or HTTP API URL and return text content or a readable failure message.',
+    schema: z.object({
+        url: z.string().describe('The HTTP or HTTPS URL to fetch.'),
+    }),
+    permissionLevel: 'network',
+});
+const webSearchTool = create900Tool(async ({ query }) => webSearchToolImpl(query), {
+    name: 'web_search_tool',
+    description: 'Search the web using Tavily and return relevant results.',
+    schema: z.object({
+        query: z.string().describe('The web search query.'),
+    }),
+    permissionLevel: 'network',
+});
+const memoryCreateTool = create900Tool(async ({ type, content, keywords, importance }, config) => {
+    const threadId = config?.configurable?.thread_id;
+    return memoryCreateToolImpl(type, content, keywords, importance, threadId);
+}, {
+    name: 'memory_create_tool',
+    description: '当用户要求记住、保存、记录某些信息，或对话中产生了值得长期保留的事实、事件、偏好或技能时，调用此工具将记忆写入数据库。',
+    schema: z.object({
+        type: z
+            .enum(['fact', 'event', 'preference', 'skill'])
+            .describe('记忆类型：fact（事实）、event（事件）、preference（偏好）、skill（技能）。'),
+        content: z.string().describe('需要保存的记忆内容，用自然语言描述。'),
+        keywords: z.array(z.string()).optional().describe('用于检索的关键词列表。'),
+        importance: z.number().min(1).max(5).optional().describe('重要程度，1~5，默认3。'),
+    }),
+    permissionLevel: 'db',
+});
+const memoryRetrieveTool = create900Tool(async ({ query, limit }) => memoryRetrieveToolImpl(query, limit), {
+    name: 'memory_retrieve_tool',
+    description: '当当前对话上下文中没有用户所需信息时，根据整理的关键词静默调用此工具从长期记忆数据库中检索相关内容。调用前不要向用户说明正在检索记忆，直接调用即可。',
+    schema: z.object({
+        query: z
+            .string()
+            .describe('搜索查询短语，由用户输入整理的关键词组成（空格分隔多个关键词）。'),
+        limit: z.number().min(1).max(50).optional().describe('返回结果数量上限，默认 10。'),
+    }),
+    permissionLevel: 'db',
+});
+const memoryDeleteTool = create900Tool(async ({ id }) => memoryDeleteToolImpl(id), {
+    name: 'memory_delete_tool',
+    description: '当用户要求删除或遗忘某条记忆时，调用此工具从数据库中删除指定 id 的记忆。',
+    schema: z.object({
+        id: z.number().int().positive().describe('要删除的记忆 id。'),
+    }),
+    permissionLevel: 'db',
+});
+const profileUpdateTool = create900Tool(async ({ content }) => profileUpdateToolImpl(content), {
+    name: 'profile_update_tool',
+    description: '当用户的基本身份、外貌、性格、兴趣爱好、技能、工作等 profile 信息发生变化时，调用此工具更新 profile 文件。更新时必须包含所有已有的 profile 信息，完整写入，不能只写变更的部分。',
+    schema: z.object({
+        content: z.string().describe('完整的 profile 内容，需包含所有已有的 profile 信息，不能遗漏。'),
+    }),
+    permissionLevel: 'write',
+});
+const agentTool = create900Tool(async ({ prompt }, config) => {
+    const parentThreadId = config?.configurable
+        ?.thread_id;
+    return agentToolImpl(prompt, parentThreadId);
+}, {
+    name: 'agent_tool',
+    description: 'Start exactly one subagent with a plain text prompt. The subagent has its own isolated context and cannot start nested subagents.',
+    schema: agentToolSchema,
+    permissionLevel: 'exec',
+});
+export const baseTools = [
+    // search,
+    loadSkillTool,
+    readFileTool,
+    writeFileTool,
+    execTool,
+    runJsTool,
+    runPyTool,
+    webFetchUrl,
+    webSearchTool,
+    memoryCreateTool,
+    memoryRetrieveTool,
+    memoryDeleteTool,
+    profileUpdateTool,
+];
+export const tools = [...baseTools, agentTool];
+export const subagentTools = baseTools;
+export function getToolsForRunMode(mode) {
+    const base = mode === 'subagent' ? subagentTools : tools;
+    const baseNames = new Set(base.map((t) => t.name));
+    const mcpTools = getMcpToolWrappers()
+        .map((w) => {
+        if (baseNames.has(w.name)) {
+            console.warn(`[MCP] Tool name conflict: "${w.name}" already exists, skipping.`);
+            return null;
+        }
+        return create900Tool(w.invoke, {
+            name: w.name,
+            description: w.description,
+            schema: w.schema,
+            permissionLevel: 'mcp',
+        });
+    })
+        .filter(Boolean);
+    return [...base, ...mcpTools];
+}
+const PERSIST_THRESHOLD = 50_000;
+const PREVIEW_LENGTH = 2_000;
+export async function maybePersistedOutput(content, toolCallId) {
+    if (content.length <= PERSIST_THRESHOLD) {
+        return content;
+    }
+    const dir = path.join(os.homedir(), '.900', '.tool_output');
+    await mkdir(dir, { recursive: true });
+    const filePath = `${dir}/tool_output_${toolCallId}.txt`;
+    await writeFile(filePath, content, 'utf8');
+    return [
+        '<persisted-output>',
+        `Output too large (${(content.length / 1024).toFixed(1)}KB).`,
+        `Full output saved to: ${filePath}`,
+        'If you need the complete content, it is recommended to read it in segments',
+        '',
+        'Preview (first 2KB):',
+        content.slice(0, PREVIEW_LENGTH),
+        '...',
+        '</persisted-output>',
+    ].join('\n');
+}

package/dist/cli/command/compact/index.js

@@ -0,0 +1,14 @@
+import chalk from 'chalk';
+import { compressContext } from '../../../agent/index.js';
+export async function handleCompactCommand(threadId) {
+    const result = await compressContext(threadId);
+    if (!result) {
+        console.log(chalk.yellow('没有可压缩的消息，或压缩失败。'));
+        return null;
+    }
+    console.log(chalk.yellow.bold('[提示] Context 已压缩，下一轮对话将使用摘要替代早期历史消息。'));
+    if (result.compressionCount >= 3) {
+        console.log(chalk.red.bold('[警告] 已多次压缩 Context，信息丢失风险很高，强烈建议输入 /new 命令开启新会话'));
+    }
+    return result;
+}

package/dist/cli/command/index.js

@@ -0,0 +1,62 @@
+import { handleCompactCommand } from './compact/index.js';
+import { handleInvalidCommand } from './invalid/index.js';
+import { handleNewCommand } from './new/index.js';
+import { handleRewindCommand } from './rewind/index.js';
+import { handleSessionCommand } from './session/index.js';
+import { handleUnknownCommand } from './unknown/index.js';
+export function parseSlashCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith('/'))
+        return null;
+    const [rawName = '', ...args] = trimmed.slice(1).split(/\s+/);
+    const name = rawName.toLowerCase();
+    if (name === 'new') {
+        if (args.length > 0)
+            return { type: 'invalid', message: '/new 不接受参数' };
+        return { type: 'new' };
+    }
+    if (name === 'session') {
+        if (args.length > 0)
+            return { type: 'invalid', message: '/session 不接受参数' };
+        return { type: 'session' };
+    }
+    if (name === 'rewind') {
+        if (args.length !== 1 || !args[0]) {
+            return { type: 'invalid', message: '/rewind 需要 1 个参数：thread_id' };
+        }
+        return { type: 'rewind', threadId: args[0] };
+    }
+    if (name === 'compact') {
+        if (args.length > 0)
+            return { type: 'invalid', message: '/compact 不接受参数' };
+        return { type: 'compact' };
+    }
+    return { type: 'unknown', name, args };
+}
+export async function handleSlashCommand(input, threadId) {
+    const slashCommand = parseSlashCommand(input);
+    if (!slashCommand)
+        return { handled: false };
+    switch (slashCommand.type) {
+        case 'new': {
+            const result = handleNewCommand();
+            return { handled: true, session: result.session };
+        }
+        case 'session':
+            handleSessionCommand();
+            return { handled: true };
+        case 'rewind': {
+            const result = handleRewindCommand(slashCommand.threadId);
+            return { handled: true, session: result.session };
+        }
+        case 'compact':
+            await handleCompactCommand(threadId);
+            return { handled: true };
+        case 'invalid':
+            handleInvalidCommand(slashCommand.message);
+            return { handled: true };
+        case 'unknown':
+            handleUnknownCommand(slashCommand.name);
+            return { handled: true };
+    }
+}

package/dist/cli/command/invalid/index.js

@@ -0,0 +1,4 @@
+import chalk from 'chalk';
+export function handleInvalidCommand(message) {
+    console.log(chalk.yellow(message));
+}

package/dist/cli/command/new/chat-session.js

@@ -0,0 +1,10 @@
+import * as crypto from 'node:crypto';
+const THREAD_ID_PREFIX = 'user-session';
+export function createThreadId() {
+    return `${THREAD_ID_PREFIX}-${crypto.randomUUID()}`;
+}
+export function createNewSession() {
+    return {
+        threadId: createThreadId(),
+    };
+}

package/dist/cli/command/new/index.js

@@ -0,0 +1,8 @@
+import chalk from 'chalk';
+import { createNewSession } from './chat-session.js';
+export function handleNewCommand() {
+    console.log(chalk.dim('已开启新会话。'));
+    return {
+        session: createNewSession(),
+    };
+}

package/dist/cli/command/rewind/index.js

@@ -0,0 +1,19 @@
+import chalk from 'chalk';
+import { threadExists } from '../../../db/index.js';
+export function handleRewindCommand(threadId) {
+    let exists;
+    try {
+        exists = threadExists(threadId);
+    }
+    catch (err) {
+        console.log(chalk.red(`查询会话失败：${err.message}`));
+        return {};
+    }
+    if (!exists) {
+        console.log(chalk.red(`未找到 thread_id：${threadId}`));
+        console.log(chalk.dim('可输入 /session 查看最近会话。'));
+        return {};
+    }
+    console.log(chalk.dim(`已恢复至会话 ${threadId}。`));
+    return { session: { threadId } };
+}

package/dist/cli/command/rewind/rewind-command.test.js

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { parseSlashCommand } from '../index.js';
+describe('parseSlashCommand /rewind', () => {
+    it('识别 /rewind <thread_id>', () => {
+        expect(parseSlashCommand('/rewind user-session-1')).toEqual({
+            type: 'rewind',
+            threadId: 'user-session-1',
+        });
+    });
+    it('/rewind 缺少参数时返回 invalid', () => {
+        expect(parseSlashCommand('/rewind')).toEqual({
+            type: 'invalid',
+            message: '/rewind 需要 1 个参数：thread_id',
+        });
+    });
+    it('/rewind 多余参数时返回 invalid', () => {
+        expect(parseSlashCommand('/rewind a b')).toEqual({
+            type: 'invalid',
+            message: '/rewind 需要 1 个参数：thread_id',
+        });
+    });
+});

package/dist/cli/command/session/format.js

@@ -0,0 +1,32 @@
+// 把 ISO 时间戳格式化成人类友好的相对时间。
+// 阈值：< 1 分钟 → 刚刚；< 60 分钟 → X 分钟前；< 24 小时 → X 小时前；
+// < 7 天 → X 天前；其余 → YYYY-MM-DD。
+export function formatRelativeTime(iso, now = new Date()) {
+    const t = new Date(iso).getTime();
+    if (Number.isNaN(t))
+        return '-';
+    const diffSec = Math.max(0, Math.floor((now.getTime() - t) / 1000));
+    if (diffSec < 60)
+        return '刚刚';
+    const diffMin = Math.floor(diffSec / 60);
+    if (diffMin < 60)
+        return `${diffMin} 分钟前`;
+    const diffHour = Math.floor(diffMin / 60);
+    if (diffHour < 24)
+        return `${diffHour} 小时前`;
+    const diffDay = Math.floor(diffHour / 24);
+    if (diffDay < 7)
+        return `${diffDay} 天前`;
+    const d = new Date(iso);
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, '0');
+    const dd = String(d.getDate()).padStart(2, '0');
+    return `${yyyy}-${mm}-${dd}`;
+}
+// 截取前 N 个字符，超出加省略号；先把换行/制表符替成空格防止破坏表格。
+export function truncate(text, max) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    if (flat.length <= max)
+        return flat;
+    return `${flat.slice(0, max)}…`;
+}

package/dist/cli/command/session/index.js

@@ -0,0 +1,32 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { fetchRecentSessions } from '../../../db/index.js';
+import { formatRelativeTime, truncate } from './format.js';
+const CONTENT_PREVIEW_LIMIT = 50;
+export function handleSessionCommand() {
+    let sessions;
+    try {
+        sessions = fetchRecentSessions();
+    }
+    catch (err) {
+        console.log(chalk.red(`读取会话记录失败：${err.message}`));
+        return;
+    }
+    if (sessions.length === 0) {
+        console.log(chalk.dim('暂无聊天记录。'));
+        return;
+    }
+    const now = new Date();
+    const table = new Table({
+        head: [chalk.bold('thread_id'), chalk.bold('最后用户输入的问题'), chalk.bold('时间')],
+        style: { head: [], border: [] },
+    });
+    for (const s of sessions) {
+        table.push([
+            s.threadId,
+            truncate(s.lastUserInput, CONTENT_PREVIEW_LIMIT),
+            formatRelativeTime(s.ts, now),
+        ]);
+    }
+    console.log(table.toString());
+}

package/dist/cli/command/session/session-command.test.js

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest';
+import { parseSlashCommand } from '../index.js';
+import { formatRelativeTime, truncate } from './format.js';
+describe('formatRelativeTime', () => {
+    const now = new Date('2026-06-16T10:00:00.000Z');
+    it('< 1 分钟显示为「刚刚」', () => {
+        expect(formatRelativeTime('2026-06-16T09:59:30.000Z', now)).toBe('刚刚');
+    });
+    it('1 分钟前', () => {
+        expect(formatRelativeTime('2026-06-16T09:59:00.000Z', now)).toBe('1 分钟前');
+    });
+    it('5 分钟前', () => {
+        expect(formatRelativeTime('2026-06-16T09:55:00.000Z', now)).toBe('5 分钟前');
+    });
+    it('1 小时前', () => {
+        expect(formatRelativeTime('2026-06-16T09:00:00.000Z', now)).toBe('1 小时前');
+    });
+    it('3 天前', () => {
+        expect(formatRelativeTime('2026-06-13T10:00:00.000Z', now)).toBe('3 天前');
+    });
+    it('一周以上显示为日期', () => {
+        expect(formatRelativeTime('2026-06-01T10:00:00.000Z', now)).toMatch(/\d{4}-\d{2}-\d{2}/);
+    });
+    it('无效时间字符串返回 -', () => {
+        expect(formatRelativeTime('not-a-date', now)).toBe('-');
+    });
+});
+describe('truncate', () => {
+    it('短于上限原样返回', () => {
+        expect(truncate('hello', 10)).toBe('hello');
+    });
+    it('长于上限截断并补省略号', () => {
+        expect(truncate('a'.repeat(60), 50)).toBe(`${'a'.repeat(50)}…`);
+    });
+    it('压扁换行/空白', () => {
+        expect(truncate('a\nb\t c', 10)).toBe('a b c');
+    });
+});
+describe('parseSlashCommand /session', () => {
+    it('识别 /session', () => {
+        expect(parseSlashCommand('/session')).toEqual({ type: 'session' });
+    });
+    it('/session 不接受参数', () => {
+        expect(parseSlashCommand('/session foo')).toEqual({
+            type: 'invalid',
+            message: '/session 不接受参数',
+        });
+    });
+});

package/dist/cli/command/unknown/index.js

@@ -0,0 +1,4 @@
+import chalk from 'chalk';
+export function handleUnknownCommand(name) {
+    console.log(chalk.yellow(`未知命令：/${name}`));
+}

package/dist/cli/index.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+import * as readline from 'node:readline';
+import * as fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { compressContext, runAgentStream } from '../agent/index.js';
+import { getModelContextWindow } from '../agent/context/index.js';
+import { getModelConfig } from '../agent/config/index.js';
+import { shouldCompress } from '../agent/context/compress.js';
+import { createNewSession } from '../cli/command/new/chat-session.js';
+import { handleSlashCommand } from '../cli/command/index.js';
+import { formatTokenFooter, formatTokenWarning } from '../agent/context/token.js';
+import { runStopHook, runUserPromptSubmitHook } from '../agent/hooks/index.js';
+const packageJsonPath = fileURLToPath(new URL('../../package.json', import.meta.url));
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+function createInterface() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+function prompt(rl, question) {
+    return new Promise((resolve) => rl.question(question, resolve));
+}
+async function chat(rl, userInput, threadId) {
+    rl.pause();
+    const abortController = new AbortController();
+    const wasRaw = process.stdin.isTTY ? process.stdin.isRaw : false;
+    process.stdout.write(`\n${chalk.cyan.bold('AI:')} `);
+    readline.emitKeypressEvents(process.stdin, rl);
+    if (process.stdin.isTTY)
+        process.stdin.setRawMode(true);
+    process.stdin.resume();
+    const onKeyPress = (_input, key) => {
+        if ((key.name !== 'escape' && key.name !== 'esc') || abortController.signal.aborted)
+            return;
+        abortController.abort();
+        process.stdout.write(`\n${chalk.yellow('[已取消]')}`);
+    };
+    process.stdin.on('keypress', onKeyPress);
+    let usage = null;
+    try {
+        const result = await runAgentStream(userInput, (content) => {
+            process.stdout.write(content);
+        }, threadId, {
+            signal: abortController.signal,
+            onConfirm: async (info) => {
+                // 切回 normal mode 以便用户输入
+                if (process.stdin.isTTY)
+                    process.stdin.setRawMode(false);
+                process.stdout.write(`\n${chalk.yellow.bold('[确认]')} 模型请求执行工具: ${chalk.cyan(info.toolName)}\n`);
+                process.stdout.write(`${chalk.dim('参数:')} ${JSON.stringify(info.args)}\n`);
+                const answer = await prompt(rl, chalk.yellow('是否执行? (y/n): '));
+                // 恢复 raw mode
+                if (process.stdin.isTTY)
+                    process.stdin.setRawMode(true);
+                return answer.trim().toLowerCase() === 'y' || answer.trim().toLowerCase() === 'yes';
+            },
+        });
+        usage = result.usage;
+    }
+    catch (err) {
+        if (!abortController.signal.aborted)
+            throw err;
+    }
+    finally {
+        process.stdin.off('keypress', onKeyPress);
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(wasRaw);
+        if (usage && !abortController.signal.aborted) {
+            const contextWindow = getModelContextWindow(getModelConfig().model);
+            process.stdout.write(`\n${formatTokenFooter(usage, contextWindow)}`);
+            const warning = formatTokenWarning(usage, contextWindow);
+            if (warning)
+                process.stdout.write(`\n${warning}`);
+            // token 占比 ≥ 80% 时自动触发 context 压缩。
+            if (shouldCompress(usage, contextWindow)) {
+                // 触发 context 压缩；具体逻辑封装在 agent 模块，避免 CLI 直接操作状态。
+                const result = await compressContext(threadId);
+                if (result?.compressed) {
+                    process.stdout.write(`\n${chalk.yellow.bold('[提示] Context 已压缩，下一轮对话将使用摘要替代早期历史消息。')}`);
+                    if (result.compressionCount >= 3) {
+                        process.stdout.write(`\n${chalk.red.bold('[警告] 已多次压缩 Context，信息丢失风险很高，强烈建议输入 /new 命令开启新会话')}`);
+                    }
+                }
+            }
+        }
+        process.stdout.write('\n\n');
+        rl.resume(); // 恢复 readline
+    }
+}
+export async function startChat() {
+    const rl = createInterface();
+    let currentSession = createNewSession();
+    while (true) {
+        const userInput = await prompt(rl, chalk.green.bold('You: '));
+        const trimmedInput = userInput.trim();
+        if (!trimmedInput)
+            continue;
+        // UserPromptSubmit hook：在用户消息进入 agent 之前最后一道关卡。
+        // 用未 trim 的原文（语义上"用户提交了什么"），block 时打印 stderr 并跳过本轮。
+        const userSubmit = await runUserPromptSubmitHook({
+            event: 'UserPromptSubmit',
+            threadId: currentSession.threadId,
+            prompt: userInput,
+        });
+        if (userSubmit.block) {
+            console.log(chalk.red(userSubmit.block.message));
+            continue;
+        }
+        if (trimmedInput.toLowerCase() === 'exit') {
+            console.log(chalk.dim('再见！'));
+            await runStopHook({ event: 'Stop', threadId: currentSession.threadId, reason: 'exit' });
+            rl.close();
+            break;
+        }
+        const slashCommandResult = await handleSlashCommand(trimmedInput, currentSession.threadId);
+        if (slashCommandResult.handled) {
+            if (slashCommandResult.session) {
+                // 旧 threadId 触发 Stop（thread 视角上结束了），新 session 那边由 SessionStart 接上。
+                await runStopHook({
+                    event: 'Stop',
+                    threadId: currentSession.threadId,
+                    reason: 'new-session',
+                });
+                currentSession = slashCommandResult.session;
+            }
+            continue;
+        }
+        try {
+            await chat(rl, userInput, currentSession.threadId);
+        }
+        catch (err) {
+            console.error(chalk.red.bold('请求出错:'), chalk.red(err.message));
+        }
+    }
+}
+export function createCommand() {
+    return new Command()
+        .name(packageJson.name)
+        .description(packageJson.description ?? '')
+        .version(packageJson.version);
+}

package/dist/db/checkpointer.js

@@ -0,0 +1,15 @@
+import { SqliteSaver } from '@langchain/langgraph-checkpoint-sqlite';
+import { CHECKPOINT_DB_PATH, ensureDataDir } from './path.js';
+import { MEMORY_TABLE_SQL } from './tables/memory.js';
+import { MEMORY_FTS_REBUILD_SQL, MEMORY_FTS_TABLE_SQL, MEMORY_FTS_TRIGGERS_SQL, } from './tables/memory_fts.js';
+export function initCheckpointer() {
+    ensureDataDir();
+    const checkpointer = SqliteSaver.fromConnString(CHECKPOINT_DB_PATH);
+    // 1. 创建主表；2. 创建 FTS5 虚拟表；3. 创建同步 trigger；4. 重建索引填充已有数据
+    checkpointer.db.exec(MEMORY_TABLE_SQL);
+    checkpointer.db.exec(MEMORY_FTS_TABLE_SQL);
+    checkpointer.db.exec(MEMORY_FTS_TRIGGERS_SQL);
+    checkpointer.db.exec(MEMORY_FTS_REBUILD_SQL);
+    return checkpointer;
+}
+export const checkpointer = initCheckpointer();

package/dist/db/index.js

@@ -0,0 +1,2 @@
+export { checkpointer } from './checkpointer.js';
+export { fetchRecentSessions, threadExists } from './sessions.js';

package/dist/db/path.js

@@ -0,0 +1,8 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+export const DATA_DIR = path.join(os.homedir(), '.900', '.data');
+export const CHECKPOINT_DB_PATH = path.join(DATA_DIR, 'checkpointer.db');
+export function ensureDataDir() {
+    fs.mkdirSync(DATA_DIR, { recursive: true });
+}