zhitalk 0.0.0 → 0.0.2

package/dist/agent/tools/memory_create_tool.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryCreateTool = memoryCreateTool;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const db_1 = require("../db");
+const VALID_TYPES = ['fact', 'event', 'preference', 'skill'];
+async function memoryCreateTool({ type, content, keywords, importance, }, config) {
+    if (!VALID_TYPES.includes(type)) {
+        return `Error: type must be one of ${VALID_TYPES.join(', ')}.`;
+    }
+    const trimmed = content?.trim();
+    if (!trimmed) {
+        return 'Error: content is required.';
+    }
+    const importanceValue = importance ?? 3;
+    if (importanceValue < 1 || importanceValue > 5) {
+        return 'Error: importance must be between 1 and 5.';
+    }
+    const sessionId = config?.configurable?.thread_id ?? 'default-session';
+    const keywordsJson = keywords && keywords.length > 0 ? JSON.stringify(keywords) : null;
+    const db = new better_sqlite3_1.default(db_1.DB_PATH);
+    try {
+        const stmt = db.prepare(`INSERT INTO memory (type, content, keywords, importance, session_id)
+       VALUES (?, ?, ?, ?, ?)`);
+        stmt.run(type, trimmed, keywordsJson, importanceValue, sessionId);
+        return 'Memory saved successfully.';
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/agent/tools/memory_delete_tool.d.ts

@@ -0,0 +1,3 @@
+export declare function memoryDeleteTool({ id, }: {
+    id: number;
+}, _config?: any): Promise<string>;

package/dist/agent/tools/memory_delete_tool.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryDeleteTool = memoryDeleteTool;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const db_1 = require("../db");
+async function memoryDeleteTool({ id, }, _config) {
+    if (!Number.isFinite(id) || id <= 0) {
+        return 'Error: id must be a positive integer.';
+    }
+    const db = new better_sqlite3_1.default(db_1.DB_PATH);
+    try {
+        const existing = db.prepare('SELECT 1 FROM memory WHERE id = ?').get(id);
+        if (!existing) {
+            return `Error: no memory found with id ${id}.`;
+        }
+        db.prepare('DELETE FROM memory WHERE id = ?').run(id);
+        return `Memory ${id} deleted successfully.`;
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/agent/tools/memory_retrieve_tool.d.ts

@@ -0,0 +1,4 @@
+export declare function memoryRetrieveTool({ query, limit, }: {
+    query: string[];
+    limit?: number;
+}, config?: any): Promise<string>;

package/dist/agent/tools/memory_retrieve_tool.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryRetrieveTool = memoryRetrieveTool;
+const db_1 = require("../db");
+async function memoryRetrieveTool({ query, limit, }, config) {
+    const trimmedQueries = query?.map((q) => q.trim()).filter((q) => q.length > 0);
+    if (!trimmedQueries || trimmedQueries.length === 0) {
+        return 'Error: query is required.';
+    }
+    const limitValue = limit ?? 10;
+    if (limitValue < 1 || limitValue > 50) {
+        return 'Error: limit must be between 1 and 50.';
+    }
+    try {
+        const results = (0, db_1.searchMemories)(trimmedQueries, limitValue);
+        if (results.length === 0) {
+            return 'No relevant memories found.';
+        }
+        return JSON.stringify(results);
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+}

package/dist/agent/tools/profile_update_tool.d.ts

@@ -0,0 +1,3 @@
+export declare function profileUpdateTool({ profile_info, }: {
+    profile_info: string;
+}): Promise<string>;

package/dist/agent/tools/profile_update_tool.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.profileUpdateTool = profileUpdateTool;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const config_1 = require("../config");
+function getProfilePaths() {
+    const dir = (0, path_1.resolve)(config_1.WORKSPACE_DIR, '.data');
+    return { dir, path: (0, path_1.resolve)(dir, 'profile.md') };
+}
+function generateBackupFilename() {
+    const dt = Date.now();
+    const random = Math.random().toString(36).slice(2, 8);
+    return `profile.${dt}-${random}.md`;
+}
+async function profileUpdateTool({ profile_info, }) {
+    if (!profile_info || profile_info.trim().length === 0) {
+        return 'Error: profile_info is empty.';
+    }
+    const { dir: profileDir, path: profilePath } = getProfilePaths();
+    try {
+        let existingContent = '';
+        let fileExists = false;
+        try {
+            existingContent = await (0, promises_1.readFile)(profilePath, 'utf-8');
+            fileExists = true;
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                return `Error reading existing profile: ${err.message}`;
+            }
+        }
+        const normalizedNew = profile_info.trim();
+        const normalizedExisting = existingContent.trim();
+        if (fileExists && normalizedNew === normalizedExisting) {
+            return 'Profile is already up to date. No changes made.';
+        }
+        await (0, promises_1.mkdir)(profileDir, { recursive: true });
+        if (fileExists) {
+            const backupFilename = generateBackupFilename();
+            const backupPath = (0, path_1.resolve)(profileDir, backupFilename);
+            await (0, promises_1.copyFile)(profilePath, backupPath);
+        }
+        await (0, promises_1.writeFile)(profilePath, profile_info, 'utf-8');
+        return `Profile updated successfully. File: ${profilePath}${fileExists ? ' (backup created)' : ''}`;
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+}

package/dist/agent/tools/read_file_tool.d.ts

@@ -0,0 +1,3 @@
+export declare function readFileTool({ filepath }: {
+    filepath: string;
+}): Promise<string>;

package/dist/agent/tools/read_file_tool.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFileTool = readFileTool;
+const promises_1 = require("fs/promises");
+async function readFileTool({ filepath }) {
+    try {
+        const content = await (0, promises_1.readFile)(filepath, 'utf-8');
+        return content;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return 'Error: file not found.';
+        }
+        return `Error: ${err.message}`;
+    }
+}

package/dist/agent/tools/run_js_tool.d.ts

@@ -0,0 +1,3 @@
+export declare function runJsTool({ code }: {
+    code: string;
+}): Promise<string>;

package/dist/agent/tools/run_js_tool.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runJsTool = runJsTool;
+const child_process_1 = require("child_process");
+async function runJsTool({ code }) {
+    if (!code.trim()) {
+        return 'Error: code is empty.';
+    }
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)('node', ['--input-type=module'], {
+            env: { ...process.env, NO_COLOR: '1', FORCE_COLOR: '0' },
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                resolve(`Error: ${stderr.trim() || 'unknown error'}`);
+            }
+            else {
+                const output = stdout || stderr;
+                resolve(output.trim() ? output : 'Code executed successfully with no output.');
+            }
+        });
+        child.on('error', (err) => {
+            resolve(`Error: ${err.message}`);
+        });
+        child.stdin.write(code);
+        child.stdin.end();
+    });
+}

package/dist/agent/tools/run_py_tool.d.ts

@@ -0,0 +1,3 @@
+export declare function runPyTool({ code }: {
+    code: string;
+}): Promise<string>;

package/dist/agent/tools/run_py_tool.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPyTool = runPyTool;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+async function runPyTool({ code }) {
+    const trimmed = code.trim();
+    if (!trimmed) {
+        return 'Error: code is empty.';
+    }
+    try {
+        await execAsync('python3 --version', { timeout: 5000 });
+    }
+    catch {
+        return 'Error: Python3 is not installed on this system. Please install Python3 to execute Python code.';
+    }
+    const base64Code = Buffer.from(trimmed).toString('base64');
+    const command = `python3 -c "import base64; exec(base64.b64decode('${base64Code}').decode('utf-8'))"`;
+    try {
+        const { stdout, stderr } = await execAsync(command, { cwd: process.cwd(), timeout: 30000 });
+        return stdout || stderr || 'Code executed successfully with no output.';
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+}

package/dist/agent/tools/search.d.ts

@@ -0,0 +1,3 @@
+export declare function search({ query }: {
+    query: string;
+}): Promise<string>;

package/dist/agent/tools/search.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.search = search;
+async function search({ query }) {
+    if (query.toLowerCase().includes('sf') ||
+        query.toLowerCase().includes('san francisco')) {
+        return "It's 60 degrees and foggy.";
+    }
+    return "It's 90 degrees and sunny.";
+}

package/dist/agent/tools/web_fetch_tool.d.ts

@@ -0,0 +1,3 @@
+export declare function webFetchTool({ url }: {
+    url: string;
+}): Promise<string>;

package/dist/agent/tools/web_fetch_tool.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webFetchTool = webFetchTool;
+const MAX_LENGTH = 8000;
+async function webFetchTool({ url }) {
+    const trimmed = url.trim();
+    if (!trimmed) {
+        return 'Error: url is empty.';
+    }
+    try {
+        const response = await fetch(trimmed, {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (compatible; ZhitalkBot/1.0)',
+            },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!response.ok) {
+            return `Error: HTTP ${response.status} ${response.statusText}`;
+        }
+        const text = await response.text();
+        if (text.length > MAX_LENGTH) {
+            return text.slice(0, MAX_LENGTH) + '\n\n[Content truncated due to length]';
+        }
+        return text;
+    }
+    catch (err) {
+        const error = err;
+        if (error.name === 'AbortError' || error.name === 'TimeoutError') {
+            return 'Error: Request timed out after 10 seconds.';
+        }
+        return `Error: ${error.message}`;
+    }
+}

package/dist/agent/tools/web_search_tool.d.ts

@@ -0,0 +1,3 @@
+export declare function webSearchTool({ query }: {
+    query: string;
+}): Promise<string>;

package/dist/agent/tools/web_search_tool.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webSearchTool = webSearchTool;
+const tavily_1 = require("@langchain/tavily");
+const config_1 = require("../config");
+async function webSearchTool({ query }) {
+    const tavilyApiKey = (0, config_1.getEnv)('TAVILY_API_KEY');
+    if (!tavilyApiKey) {
+        return 'Error: 未配置 TAVILY_API_KEY。请在 ~/.zhitalk/zhitalk.json 的 env 中设置 TAVILY_API_KEY。';
+    }
+    const tavilySearch = new tavily_1.TavilySearch({
+        maxResults: 3,
+        topic: 'general',
+        tavilyApiKey,
+    });
+    try {
+        const result = await tavilySearch.invoke({ query });
+        if ('error' in result && result.error) {
+            return `Error: ${result.error}`;
+        }
+        const lines = [];
+        lines.push(`Query: ${result.query}`);
+        if (result.answer) {
+            lines.push(`Answer: ${result.answer}`);
+        }
+        lines.push('');
+        lines.push('Results:');
+        for (let i = 0; i < result.results.length; i++) {
+            const r = result.results[i];
+            lines.push(`${i + 1}. ${r.title} (${r.url})`);
+            lines.push(`   ${r.content}`);
+        }
+        return lines.join('\n');
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+}

package/dist/agent/tools/write_file_tool.d.ts

@@ -0,0 +1,4 @@
+export declare function writeFileTool({ filepath, content }: {
+    filepath: string;
+    content: string;
+}): Promise<string>;

package/dist/agent/tools/write_file_tool.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFileTool = writeFileTool;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+async function writeFileTool({ filepath, content }) {
+    try {
+        await (0, promises_1.mkdir)((0, path_1.dirname)(filepath), { recursive: true });
+        await (0, promises_1.writeFile)(filepath, content, 'utf-8');
+        return `File "${filepath}" written successfully.`;
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+}

package/dist/agent/tools.d.ts

@@ -0,0 +1,8 @@
+import { DynamicStructuredTool } from '@langchain/core/tools';
+export type ZhitalkTool = DynamicStructuredTool & {
+    permission_level: string;
+};
+export declare function maybePersistedOutput(content: string, toolCallId: string): Promise<string>;
+export declare const nativeTools: ZhitalkTool[];
+export declare let tools: ZhitalkTool[];
+export declare function initTools(): Promise<void>;

package/dist/agent/tools.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tools = exports.nativeTools = void 0;
+exports.maybePersistedOutput = maybePersistedOutput;
+exports.initTools = initTools;
+const tools_1 = require("@langchain/core/tools");
+const zod_1 = require("zod");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const config_1 = require("./config");
+const read_file_tool_1 = require("./tools/read_file_tool");
+const write_file_tool_1 = require("./tools/write_file_tool");
+const exec_tool_1 = require("./tools/exec_tool");
+const run_js_tool_1 = require("./tools/run_js_tool");
+const run_py_tool_1 = require("./tools/run_py_tool");
+const web_search_tool_1 = require("./tools/web_search_tool");
+const web_fetch_tool_1 = require("./tools/web_fetch_tool");
+const load_skill_tool_1 = require("./tools/load_skill_tool");
+const memory_create_tool_1 = require("./tools/memory_create_tool");
+const memory_retrieve_tool_1 = require("./tools/memory_retrieve_tool");
+const memory_delete_tool_1 = require("./tools/memory_delete_tool");
+const profile_update_tool_1 = require("./tools/profile_update_tool");
+const agent_tool_1 = require("./tools/agent_tool");
+const mcp_1 = require("./mcp");
+function createZhitalkTool(impl, options, permission_level) {
+    const t = (0, tools_1.tool)(impl, options);
+    t.permission_level = permission_level;
+    return t;
+}
+const readFileTool = createZhitalkTool(read_file_tool_1.readFileTool, {
+    name: 'read_file',
+    description: 'Read the contents of a file.',
+    schema: zod_1.z.object({
+        filepath: zod_1.z.string().describe('The path of the file to read. Can be relative, absolute, or start with ~.'),
+    }),
+}, 'read');
+const writeFileTool = createZhitalkTool(write_file_tool_1.writeFileTool, {
+    name: 'write_file',
+    description: 'Create or overwrite a file. Will create parent directories if needed.',
+    schema: zod_1.z.object({
+        filepath: zod_1.z.string().describe('The path of the file to write. Can be relative, absolute, or start with ~.'),
+        content: zod_1.z.string().describe('The content to write to the file.'),
+    }),
+}, 'write');
+const execTool = createZhitalkTool(exec_tool_1.execTool, {
+    name: 'exec',
+    description: 'Execute a safe shell command in the current directory. Dangerous commands (rm, rmdir, etc.), absolute paths, and parent directory references are blocked.',
+    schema: zod_1.z.object({
+        command: zod_1.z.string().describe('The shell command to execute.'),
+    }),
+}, 'exec');
+const runJsTool = createZhitalkTool(run_js_tool_1.runJsTool, {
+    name: 'run_js',
+    description: 'Execute JavaScript code using Node.js in the current directory. Returns stdout/stderr or error messages.',
+    schema: zod_1.z.object({
+        code: zod_1.z.string().describe('The JavaScript code to execute.'),
+    }),
+}, 'exec');
+const runPyTool = createZhitalkTool(run_py_tool_1.runPyTool, {
+    name: 'run_py',
+    description: 'Execute Python code using Python3 in the current directory. Returns stdout/stderr or error messages.',
+    schema: zod_1.z.object({
+        code: zod_1.z.string().describe('The Python code to execute.'),
+    }),
+}, 'exec');
+const webSearchTool = createZhitalkTool(web_search_tool_1.webSearchTool, {
+    name: 'web_search',
+    description: 'Search the web using Tavily. Useful for finding current information, news, and facts.',
+    schema: zod_1.z.object({
+        query: zod_1.z.string().describe('The search query.'),
+    }),
+}, 'network');
+const webFetchTool = createZhitalkTool(web_fetch_tool_1.webFetchTool, {
+    name: 'web_fetch',
+    description: 'Fetch the content of a web page by URL. Returns the raw HTML/text content. Useful when you need to read a specific page.',
+    schema: zod_1.z.object({
+        url: zod_1.z.string().describe('The full URL of the web page to fetch.'),
+    }),
+}, 'network');
+const loadSkillTool = createZhitalkTool(load_skill_tool_1.loadSkillTool, {
+    name: 'load_skill',
+    description: 'Load the full content of a skill by its name. Call this when you need to use a specific skill to handle the user request. You can only load one skill at a time.',
+    schema: zod_1.z.object({
+        name: zod_1.z.string().describe('The name of the skill to load.'),
+    }),
+}, 'read');
+const memoryCreateTool = createZhitalkTool(memory_create_tool_1.memoryCreateTool, {
+    name: 'memory_create',
+    description: 'Save a piece of memory to the database. Use this when the user shares something worth remembering, such as a personal fact, event, preference, or skill.',
+    schema: zod_1.z.object({
+        type: zod_1.z
+            .enum(['fact', 'event', 'preference', 'skill'])
+            .describe('The type of memory to save.'),
+        content: zod_1.z
+            .string()
+            .describe('The natural language description of the memory.'),
+        keywords: zod_1.z
+            .array(zod_1.z.string())
+            .optional()
+            .describe('Optional keywords for retrieval, as an array of strings.'),
+        importance: zod_1.z
+            .number()
+            .min(1)
+            .max(5)
+            .optional()
+            .describe('Importance level from 1 to 5. Default is 3.'),
+    }),
+}, 'db');
+const memoryRetrieveTool = createZhitalkTool(memory_retrieve_tool_1.memoryRetrieveTool, {
+    name: 'memory_retrieve',
+    description: 'Retrieve relevant memories from the database using full-text search. Use this when the user asks about something that may have been remembered before but is not in the current conversation context. Extract a few key keywords from the question and pass them as the query.',
+    schema: zod_1.z.object({
+        query: zod_1.z
+            .array(zod_1.z.string())
+            .describe('Keywords to search for in memories.'),
+        limit: zod_1.z
+            .number()
+            .min(1)
+            .max(50)
+            .optional()
+            .describe('Maximum number of memories to return. Default is 10.'),
+    }),
+}, 'db');
+const memoryDeleteTool = createZhitalkTool(memory_delete_tool_1.memoryDeleteTool, {
+    name: 'memory_delete',
+    description: 'Delete a memory from the database by its id. Use this when the user wants to forget or remove a specific memory.',
+    schema: zod_1.z.object({
+        id: zod_1.z
+            .number()
+            .int()
+            .positive()
+            .describe('The id of the memory to delete.'),
+    }),
+}, 'db');
+const profileUpdateTool = createZhitalkTool(profile_update_tool_1.profileUpdateTool, {
+    name: 'profile_update',
+    description: "Update the user's profile information. When providing new profile info, also include all other fields mentioned in <profile_info> — all profile information must be updated together.",
+    schema: zod_1.z.object({
+        profile_info: zod_1.z
+            .string()
+            .describe('The complete profile information in markdown format, including all existing and updated fields.'),
+    }),
+}, 'write');
+const agentTool = createZhitalkTool(agent_tool_1.agentTool, {
+    name: 'agent_tool',
+    description: 'Launch a sub-agent to execute an independent task. The sub-agent has access to all tools (except this one), skills, memory, and hooks. It will run to completion and return its final result. Use this for tasks that can be delegated, such as research, code generation, or data processing.',
+    schema: zod_1.z.object({
+        prompt: zod_1.z
+            .string()
+            .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 maybePersistedOutput(content, toolCallId) {
+    const MAX_LENGTH = 50000;
+    if (content.length <= MAX_LENGTH) {
+        return content;
+    }
+    const id = toolCallId || Math.random().toString(36).slice(2, 9);
+    const dir = (0, path_1.resolve)(config_1.WORKSPACE_DIR, '.tool_output');
+    const filePath = (0, path_1.resolve)(dir, `tool_output_${id}.txt`);
+    await (0, promises_1.mkdir)(dir, { recursive: true });
+    await (0, promises_1.writeFile)(filePath, content, 'utf-8');
+    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, 2000)}
+...
+</persisted-output>`;
+}
+exports.nativeTools = [
+    readFileTool,
+    writeFileTool,
+    execTool,
+    runJsTool,
+    runPyTool,
+    webSearchTool,
+    webFetchTool,
+    loadSkillTool,
+    memoryCreateTool,
+    memoryRetrieveTool,
+    memoryDeleteTool,
+    profileUpdateTool,
+    agentTool,
+];
+exports.tools = [...exports.nativeTools];
+async function initTools() {
+    const mcpTools = await (0, mcp_1.initMcpTools)();
+    exports.tools = [...exports.nativeTools, ...mcpTools];
+}

package/dist/agent/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function formatRelativeTime(ts: string): string;
+export declare function truncate(str: string | null, maxLen: number): string;

package/dist/agent/utils.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatRelativeTime = formatRelativeTime;
+exports.truncate = truncate;
+function formatRelativeTime(ts) {
+    const diffMs = Date.now() - new Date(ts).getTime();
+    const diffMin = Math.floor(diffMs / 60000);
+    const diffHour = Math.floor(diffMin / 60);
+    const diffDay = Math.floor(diffHour / 24);
+    if (diffMin < 1)
+        return '刚刚';
+    if (diffMin < 5)
+        return '5分钟内';
+    if (diffMin < 10)
+        return '10分钟内';
+    if (diffMin < 30)
+        return '30分钟内';
+    if (diffMin < 60)
+        return '1小时内';
+    if (diffHour < 24)
+        return `${diffHour}小时内`;
+    if (diffDay < 2)
+        return '1天前';
+    return `${diffDay}天前`;
+}
+function truncate(str, maxLen) {
+    if (!str)
+        return '-';
+    return str.length > maxLen ? str.slice(0, maxLen) + '...' : str;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};