zhitalk 0.0.0 → 0.0.3

package/dist/agent/tools/agent_tool.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentTool = agentTool;
+async function agentTool({ prompt }) {
+    if (!prompt || !prompt.trim()) {
+        return 'Error: prompt is empty.';
+    }
+    // 动态 import 避免循环依赖：agent.ts -> tools.ts -> agent_tool.ts -> agent.ts
+    const { runSubAgent } = await Promise.resolve().then(() => __importStar(require('../agent')));
+    return runSubAgent(prompt.trim());
+}

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

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

package/dist/agent/tools/exec_tool.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execTool = execTool;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+async function execTool({ command }) {
+    const trimmed = command.trim();
+    if (!trimmed) {
+        return 'Error: command is empty.';
+    }
+    if (trimmed.includes('..')) {
+        return 'Error: parent directory references (..) are not allowed.';
+    }
+    const spaceIdx = trimmed.indexOf(' ');
+    const args = spaceIdx > 0 ? trimmed.slice(spaceIdx) : '';
+    const absolutePathMatch = args.match(/(?:^|\s)(\/[^ ]+)/);
+    if (absolutePathMatch) {
+        return `Error: absolute paths are not allowed: "${absolutePathMatch[1]}"`;
+    }
+    try {
+        const { stdout, stderr } = await execAsync(trimmed, { cwd: process.cwd(), timeout: 30000 });
+        return stdout || stderr || 'Command executed successfully with no output.';
+    }
+    catch (err) {
+        return `Error: ${err.message}`;
+    }
+}

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

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

package/dist/agent/tools/load_skill_tool.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSkillTool = loadSkillTool;
+const skills_1 = require("../skills");
+async function loadSkillTool({ name }) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+        return 'Error: skill name is empty.';
+    }
+    const content = (0, skills_1.loadSkill)(trimmed);
+    if (!content) {
+        return `Error: skill "${trimmed}" not found.`;
+    }
+    return content;
+}

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

@@ -0,0 +1,6 @@
+export declare function memoryCreateTool({ type, content, keywords, importance, }: {
+    type: string;
+    content: string;
+    keywords?: string[];
+    importance?: number;
+}, config?: any): Promise<string>;

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>;