zhitalk 0.0.5 → 0.0.7

package/dist/agent/tools/profile_update_tool.js

@@ -1,19 +1,16 @@
-"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");
+import { writeFile, readFile, mkdir, copyFile } from 'fs/promises';
+import { resolve } from 'path';
+import { WORKSPACE_DIR } from '../config.js';
 function getProfilePaths() {
-    const dir = (0, path_1.resolve)(config_1.WORKSPACE_DIR, '.data');
-    return { dir, path: (0, path_1.resolve)(dir, 'profile.md') };
+    const dir = resolve(WORKSPACE_DIR, '.data');
+    return { dir, path: 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, }) {
+export async function profileUpdateTool({ profile_info, }) {
     if (!profile_info || profile_info.trim().length === 0) {
         return 'Error: profile_info is empty.';
     }
@@ -22,7 +19,7 @@ async function profileUpdateTool({ profile_info, }) {
         let existingContent = '';
         let fileExists = false;
         try {
-            existingContent = await (0, promises_1.readFile)(profilePath, 'utf-8');
+            existingContent = await readFile(profilePath, 'utf-8');
             fileExists = true;
         }
         catch (err) {
@@ -35,13 +32,13 @@ async function profileUpdateTool({ profile_info, }) {
         if (fileExists && normalizedNew === normalizedExisting) {
             return 'Profile is already up to date. No changes made.';
         }
-        await (0, promises_1.mkdir)(profileDir, { recursive: true });
+        await mkdir(profileDir, { recursive: true });
         if (fileExists) {
             const backupFilename = generateBackupFilename();
-            const backupPath = (0, path_1.resolve)(profileDir, backupFilename);
-            await (0, promises_1.copyFile)(profilePath, backupPath);
+            const backupPath = resolve(profileDir, backupFilename);
+            await copyFile(profilePath, backupPath);
         }
-        await (0, promises_1.writeFile)(profilePath, profile_info, 'utf-8');
+        await writeFile(profilePath, profile_info, 'utf-8');
         return `Profile updated successfully. File: ${profilePath}${fileExists ? ' (backup created)' : ''}`;
     }
     catch (err) {

package/dist/agent/tools/read_file_tool.js

@@ -1,10 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readFileTool = readFileTool;
-const promises_1 = require("fs/promises");
-async function readFileTool({ filepath }) {
+import { readFile } from 'fs/promises';
+import { resolvePath } from '../utils.js';
+export async function readFileTool({ filepath }) {
     try {
-        const content = await (0, promises_1.readFile)(filepath, 'utf-8');
+        const content = await readFile(resolvePath(filepath), 'utf-8');
         return content;
     }
     catch (err) {

package/dist/agent/tools/run_js_tool.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runJsTool = runJsTool;
-const child_process_1 = require("child_process");
-async function runJsTool({ code }) {
+import { spawn } from 'child_process';
+export 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'], {
+        const child = spawn('node', ['--input-type=module'], {
             env: { ...process.env, NO_COLOR: '1', FORCE_COLOR: '0' },
         });
         let stdout = '';

package/dist/agent/tools/run_py_tool.js

@@ -1,10 +1,7 @@
-"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 }) {
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export async function runPyTool({ code }) {
     const trimmed = code.trim();
     if (!trimmed) {
         return 'Error: code is empty.';

package/dist/agent/tools/search.js

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

package/dist/agent/tools/web_fetch_tool.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.webFetchTool = webFetchTool;
 const MAX_LENGTH = 8000;
-async function webFetchTool({ url }) {
+export async function webFetchTool({ url }) {
     const trimmed = url.trim();
     if (!trimmed) {
         return 'Error: url is empty.';

package/dist/agent/tools/web_search_tool.js

@@ -1,14 +1,11 @@
-"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');
+import { TavilySearch } from '@langchain/tavily';
+import { getEnv } from '../config.js';
+export async function webSearchTool({ query }) {
+    const tavilyApiKey = getEnv('TAVILY_API_KEY');
     if (!tavilyApiKey) {
         return 'Error: 未配置 TAVILY_API_KEY。请在 ~/.zhitalk/zhitalk.json 的 env 中设置 TAVILY_API_KEY。';
     }
-    const tavilySearch = new tavily_1.TavilySearch({
+    const tavilySearch = new TavilySearch({
         maxResults: 3,
         topic: 'general',
         tavilyApiKey,

package/dist/agent/tools/write_file_tool.js

@@ -1,13 +1,12 @@
-"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 }) {
+import { writeFile, mkdir } from 'fs/promises';
+import { dirname } from 'path';
+import { resolvePath } from '../utils.js';
+export 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.`;
+        const absolutePath = resolvePath(filepath);
+        await mkdir(dirname(absolutePath), { recursive: true });
+        await writeFile(absolutePath, content, 'utf-8');
+        return `File "${absolutePath}" written successfully.`;
     }
     catch (err) {
         return `Error: ${err.message}`;

package/dist/agent/tools.js

@@ -1,104 +1,99 @@
-"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");
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+import { mkdir, writeFile } from 'fs/promises';
+import { resolve } from 'path';
+import { WORKSPACE_DIR } from './config.js';
+import { readFileTool as readFileToolImpl } from './tools/read_file_tool.js';
+import { writeFileTool as writeFileToolImpl } from './tools/write_file_tool.js';
+import { execTool as execToolImpl } from './tools/exec_tool.js';
+import { runJsTool as runJsToolImpl } from './tools/run_js_tool.js';
+import { runPyTool as runPyToolImpl } from './tools/run_py_tool.js';
+import { webSearchTool as webSearchToolImpl } from './tools/web_search_tool.js';
+import { webFetchTool as webFetchToolImpl } from './tools/web_fetch_tool.js';
+import { loadSkillTool as loadSkillToolImpl } from './tools/load_skill_tool.js';
+import { memoryCreateTool as memoryCreateToolImpl } from './tools/memory_create_tool.js';
+import { memoryRetrieveTool as memoryRetrieveToolImpl } from './tools/memory_retrieve_tool.js';
+import { memoryDeleteTool as memoryDeleteToolImpl } from './tools/memory_delete_tool.js';
+import { profileUpdateTool as profileUpdateToolImpl } from './tools/profile_update_tool.js';
+import { agentTool as agentToolImpl } from './tools/agent_tool.js';
+import { initMcpTools } from './mcp/index.js';
 function createZhitalkTool(impl, options, permission_level) {
-    const t = (0, tools_1.tool)(impl, options);
+    const t = tool(impl, options);
     t.permission_level = permission_level;
     return t;
 }
-const readFileTool = createZhitalkTool(read_file_tool_1.readFileTool, {
+const readFileTool = createZhitalkTool(readFileToolImpl, {
     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 ~.'),
+    schema: z.object({
+        filepath: 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, {
+const writeFileTool = createZhitalkTool(writeFileToolImpl, {
     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.'),
+    schema: z.object({
+        filepath: z.string().describe('The path of the file to write. Can be relative, absolute, or start with ~.'),
+        content: z.string().describe('The content to write to the file.'),
     }),
 }, 'write');
-const execTool = createZhitalkTool(exec_tool_1.execTool, {
+const execTool = createZhitalkTool(execToolImpl, {
     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.'),
+    schema: z.object({
+        command: z.string().describe('The shell command to execute.'),
     }),
 }, 'exec');
-const runJsTool = createZhitalkTool(run_js_tool_1.runJsTool, {
+const runJsTool = createZhitalkTool(runJsToolImpl, {
     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.'),
+    schema: z.object({
+        code: z.string().describe('The JavaScript code to execute.'),
     }),
 }, 'exec');
-const runPyTool = createZhitalkTool(run_py_tool_1.runPyTool, {
+const runPyTool = createZhitalkTool(runPyToolImpl, {
     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.'),
+    schema: z.object({
+        code: z.string().describe('The Python code to execute.'),
     }),
 }, 'exec');
-const webSearchTool = createZhitalkTool(web_search_tool_1.webSearchTool, {
+const webSearchTool = createZhitalkTool(webSearchToolImpl, {
     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.'),
+    schema: z.object({
+        query: z.string().describe('The search query.'),
     }),
 }, 'network');
-const webFetchTool = createZhitalkTool(web_fetch_tool_1.webFetchTool, {
+const webFetchTool = createZhitalkTool(webFetchToolImpl, {
     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.'),
+    schema: z.object({
+        url: z.string().describe('The full URL of the web page to fetch.'),
     }),
 }, 'network');
-const loadSkillTool = createZhitalkTool(load_skill_tool_1.loadSkillTool, {
+const loadSkillTool = createZhitalkTool(loadSkillToolImpl, {
     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.'),
+    schema: z.object({
+        name: z.string().describe('The name of the skill to load.'),
     }),
 }, 'read');
-const memoryCreateTool = createZhitalkTool(memory_create_tool_1.memoryCreateTool, {
+const memoryCreateTool = createZhitalkTool(memoryCreateToolImpl, {
     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
+    schema: z.object({
+        type: z
             .enum(['fact', 'event', 'preference', 'skill'])
             .describe('The type of memory to save.'),
-        content: zod_1.z
+        content: z
             .string()
             .describe('The natural language description of the memory.'),
-        keywords: zod_1.z
-            .array(zod_1.z.string())
+        keywords: z
+            .array(z.string())
             .optional()
             .describe('Optional keywords for retrieval, as an array of strings.'),
-        importance: zod_1.z
+        importance: z
             .number()
             .min(1)
             .max(5)
@@ -106,14 +101,14 @@ const memoryCreateTool = createZhitalkTool(memory_create_tool_1.memoryCreateTool
             .describe('Importance level from 1 to 5. Default is 3.'),
     }),
 }, 'db');
-const memoryRetrieveTool = createZhitalkTool(memory_retrieve_tool_1.memoryRetrieveTool, {
+const memoryRetrieveTool = createZhitalkTool(memoryRetrieveToolImpl, {
     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())
+    schema: z.object({
+        query: z
+            .array(z.string())
             .describe('Keywords to search for in memories.'),
-        limit: zod_1.z
+        limit: z
             .number()
             .min(1)
             .max(50)
@@ -121,45 +116,45 @@ const memoryRetrieveTool = createZhitalkTool(memory_retrieve_tool_1.memoryRetrie
             .describe('Maximum number of memories to return. Default is 10.'),
     }),
 }, 'db');
-const memoryDeleteTool = createZhitalkTool(memory_delete_tool_1.memoryDeleteTool, {
+const memoryDeleteTool = createZhitalkTool(memoryDeleteToolImpl, {
     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
+    schema: z.object({
+        id: z
             .number()
             .int()
             .positive()
             .describe('The id of the memory to delete.'),
     }),
 }, 'db');
-const profileUpdateTool = createZhitalkTool(profile_update_tool_1.profileUpdateTool, {
+const profileUpdateTool = createZhitalkTool(profileUpdateToolImpl, {
     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
+    schema: z.object({
+        profile_info: z
             .string()
             .describe('The complete profile information in markdown format, including all existing and updated fields.'),
     }),
 }, 'write');
-const agentTool = createZhitalkTool(agent_tool_1.agentTool, {
+const agentTool = createZhitalkTool(agentToolImpl, {
     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
+    schema: z.object({
+        prompt: 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) {
+export 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');
+    const dir = resolve(WORKSPACE_DIR, '.tool_output');
+    const filePath = resolve(dir, `tool_output_${id}.txt`);
+    await mkdir(dir, { recursive: true });
+    await writeFile(filePath, content, 'utf-8');
     return `<persisted-output>
 Output too large (${(content.length / 1024).toFixed(1)}KB).
 Full output saved to: ${filePath}
@@ -171,7 +166,7 @@ ${content.slice(0, 2000)}
 ...
 </persisted-output>`;
 }
-exports.nativeTools = [
+export const nativeTools = [
     readFileTool,
     writeFileTool,
     execTool,
@@ -186,8 +181,8 @@ exports.nativeTools = [
     profileUpdateTool,
     agentTool,
 ];
-exports.tools = [...exports.nativeTools];
-async function initTools() {
-    const mcpTools = await (0, mcp_1.initMcpTools)();
-    exports.tools = [...exports.nativeTools, ...mcpTools];
+export let tools = [...nativeTools];
+export async function initTools() {
+    const mcpTools = await initMcpTools();
+    tools = [...nativeTools, ...mcpTools];
 }

package/dist/agent/utils.d.ts

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

package/dist/agent/utils.js

@@ -1,8 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatRelativeTime = formatRelativeTime;
-exports.truncate = truncate;
-function formatRelativeTime(ts) {
+import { resolve, join } from 'path';
+import { homedir } from 'os';
+export function resolvePath(filepath) {
+    if (filepath.startsWith('~/')) {
+        filepath = join(homedir(), filepath.slice(2));
+    }
+    else if (filepath === '~') {
+        filepath = homedir();
+    }
+    return resolve(filepath);
+}
+export function formatRelativeTime(ts) {
     const diffMs = Date.now() - new Date(ts).getTime();
     const diffMin = Math.floor(diffMs / 60000);
     const diffHour = Math.floor(diffMin / 60);
@@ -23,7 +30,7 @@ function formatRelativeTime(ts) {
         return '1天前';
     return `${diffDay}天前`;
 }
-function truncate(str, maxLen) {
+export function truncate(str, maxLen) {
     if (!str)
         return '-';
     return str.length > maxLen ? str.slice(0, maxLen) + '...' : str;

package/dist/index.js

@@ -1,62 +1,36 @@
 #!/usr/bin/env node
-"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 });
-const commander_1 = require("commander");
-const fs_1 = require("fs");
-const path_1 = require("path");
-const config_1 = require("./agent/config");
-const pkg = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../package.json'), 'utf-8'));
+import { Command } from 'commander';
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { CONFIG_PATH } from './agent/config.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
 async function main() {
-    const program = new commander_1.Command();
+    const program = new Command();
     program.name(pkg.name).description(pkg.description).version(pkg.version);
+    program
+        .command('config')
+        .description('Print the configuration file path')
+        .action(() => {
+        console.log(`配置文件位置: ${CONFIG_PATH}`);
+        console.log('请使用编辑器打开并修改配置，修改完成后重启 zhitalk');
+    });
     if (process.argv.length > 2) {
         program.parse();
         return;
     }
-    if (!(0, fs_1.existsSync)(config_1.CONFIG_PATH)) {
-        const { runInstall } = await Promise.resolve().then(() => __importStar(require('./install')));
+    if (!existsSync(CONFIG_PATH)) {
+        const { runInstall } = await import('./install.js');
         await runInstall();
         return;
     }
-    const { initColors } = await Promise.resolve().then(() => __importStar(require('./agent/colors')));
-    const { initDb } = await Promise.resolve().then(() => __importStar(require('./agent/db')));
-    const { initAgent } = await Promise.resolve().then(() => __importStar(require('./agent/agent')));
-    const { interactiveChat } = await Promise.resolve().then(() => __importStar(require('./agent/cli')));
-    const { shutdownMcp } = await Promise.resolve().then(() => __importStar(require('./agent/mcp')));
-    const { checkModel } = await Promise.resolve().then(() => __importStar(require('./agent/model')));
+    const { initColors } = await import('./agent/colors.js');
+    const { initDb } = await import('./agent/db.js');
+    const { initAgent } = await import('./agent/agent.js');
+    const { interactiveChat } = await import('./agent/cli.js');
+    const { shutdownMcp } = await import('./agent/mcp/index.js');
+    const { checkModel } = await import('./agent/model.js');
     await initColors();
     await checkModel();
     initDb();