xiaozuoassistant 0.1.41

package/dist/server/server.js

@@ -0,0 +1,29 @@
+/**
+ * local server entry file, for local development
+ */
+import app from './app.js';
+/**
+ * start server with port
+ */
+const PORT = process.env.PORT || 3001;
+const server = app.listen(PORT, () => {
+    console.log(`Server ready on port ${PORT}`);
+});
+/**
+ * close server
+ */
+process.on('SIGTERM', () => {
+    console.log('SIGTERM signal received');
+    server.close(() => {
+        console.log('Server closed');
+        process.exit(0);
+    });
+});
+process.on('SIGINT', () => {
+    console.log('SIGINT signal received');
+    server.close(() => {
+        console.log('Server closed');
+        process.exit(0);
+    });
+});
+export default app;

package/dist/server/skills/base-skill.js

@@ -0,0 +1,16 @@
+export class BaseSkill {
+    validate(params) {
+        // 这里可以添加基于 JSON Schema 的验证逻辑
+        return true;
+    }
+    toJSON() {
+        return {
+            type: 'function',
+            function: {
+                name: this.name,
+                description: this.description,
+                parameters: this.parameters
+            }
+        };
+    }
+}

package/dist/server/skills/create-agent.js

@@ -0,0 +1,58 @@
+import { BaseSkill } from '../skills/base-skill.js';
+import { AgentRuntime } from '../core/agents/runtime.js';
+import { agentManager } from '../core/agents/manager.js';
+import { skillRegistry } from '../skills/registry.js';
+export class CreateAgentSkill extends BaseSkill {
+    constructor() {
+        super(...arguments);
+        this.name = 'create_agent';
+        this.description = 'Create a new specialized agent dynamically. Use this when the user wants to define a new role or expert.';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'The unique name of the agent (e.g., "coding_expert", "translator")'
+                },
+                description: {
+                    type: 'string',
+                    description: 'A brief description of what this agent does'
+                },
+                systemPrompt: {
+                    type: 'string',
+                    description: 'The system instructions/persona for the agent'
+                },
+                skills: {
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    },
+                    description: 'List of existing skill names to assign to this agent (e.g., ["search", "read_file"])'
+                }
+            },
+            required: ['name', 'description', 'systemPrompt']
+        };
+    }
+    async execute(args) {
+        if (agentManager.getAgent(args.name)) {
+            return { error: `Agent '${args.name}' already exists.` };
+        }
+        const assignedSkills = [];
+        if (args.skills) {
+            for (const skillName of args.skills) {
+                const skill = skillRegistry.getSkill(skillName);
+                if (skill) {
+                    assignedSkills.push(skill);
+                }
+            }
+        }
+        const newAgent = new AgentRuntime({
+            name: args.name,
+            description: args.description,
+            systemPrompt: args.systemPrompt,
+            skills: assignedSkills
+        });
+        agentManager.registerAgent(newAgent);
+        return { success: true, message: `Agent '${args.name}' created successfully.` };
+    }
+}

package/dist/server/skills/delegate.js

@@ -0,0 +1,39 @@
+import { BaseSkill } from '../skills/base-skill.js';
+import { agentManager } from '../core/agents/manager.js';
+export class DelegateSkill extends BaseSkill {
+    constructor() {
+        super(...arguments);
+        this.name = 'delegate_task';
+        this.description = 'Delegate a complex task to a specialized agent. Use this when the user asks for something that requires specific expertise (e.g., "office_agent" for documents).';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                agentName: {
+                    type: 'string',
+                    description: 'The name of the agent to delegate to (e.g., "office_agent")',
+                    enum: ['office_agent'] // Dynamically updated ideally, but hardcoded for now or fetch from manager
+                },
+                task: {
+                    type: 'string',
+                    description: 'The detailed task description for the agent'
+                }
+            },
+            required: ['agentName', 'task']
+        };
+    }
+    async execute(args) {
+        const agent = agentManager.getAgent(args.agentName);
+        if (!agent) {
+            return { error: `Agent '${args.agentName}' not found. Available agents: ${agentManager.getAllAgents().map(a => a.name).join(', ')}` };
+        }
+        console.log(`[DelegateSkill] Delegating to ${args.agentName}: ${args.task}`);
+        try {
+            // We start a fresh conversation for the sub-agent for now (stateless delegation)
+            const response = await agent.process([], args.task);
+            return { result: response, from: args.agentName };
+        }
+        catch (e) {
+            return { error: `Delegation failed: ${e.message}` };
+        }
+    }
+}

package/dist/server/skills/file-system.js

@@ -0,0 +1,137 @@
+import { BaseSkill } from './base-skill.js';
+import fs from 'fs/promises';
+import path from 'path';
+export class ListDirectorySkill extends BaseSkill {
+    constructor() {
+        super(...arguments);
+        this.name = 'fs_list_directory';
+        this.description = 'List files and directories in a given path';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'The absolute path to the directory to list. Defaults to current working directory.'
+                }
+            },
+            required: []
+        };
+    }
+    async execute(params) {
+        const dirPath = params.path ? path.resolve(params.path) : process.cwd();
+        try {
+            const files = await fs.readdir(dirPath, { withFileTypes: true });
+            return files.map(file => ({
+                name: file.name,
+                type: file.isDirectory() ? 'directory' : 'file'
+            }));
+        }
+        catch (error) {
+            return `Error listing directory: ${error.message}`;
+        }
+    }
+}
+export class ReadFileSkill extends BaseSkill {
+    constructor() {
+        super(...arguments);
+        this.name = 'fs_read_file';
+        this.description = 'Read the content of a file';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'The absolute path to the file to read'
+                },
+                encoding: {
+                    type: 'string',
+                    description: 'The encoding to use (default: utf-8)',
+                    enum: ['utf-8', 'base64']
+                }
+            },
+            required: ['path']
+        };
+    }
+    async execute(params) {
+        const filePath = path.resolve(params.path);
+        const encoding = params.encoding || 'utf-8';
+        try {
+            const content = await fs.readFile(filePath, { encoding: encoding });
+            return content;
+        }
+        catch (error) {
+            return `Error reading file: ${error.message}`;
+        }
+    }
+}
+export class WriteFileSkill extends BaseSkill {
+    constructor() {
+        super(...arguments);
+        this.name = 'fs_write_file';
+        this.description = 'Write content to a file (overwrites existing file)';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'The absolute path to the file to write'
+                },
+                content: {
+                    type: 'string',
+                    description: 'The content to write to the file'
+                }
+            },
+            required: ['path', 'content']
+        };
+    }
+    async execute(params) {
+        const filePath = path.resolve(params.path);
+        try {
+            // Ensure directory exists
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.writeFile(filePath, params.content, 'utf-8');
+            return `Successfully wrote to ${filePath}`;
+        }
+        catch (error) {
+            return `Error writing file: ${error.message}`;
+        }
+    }
+}
+export class DeleteFileSkill extends BaseSkill {
+    constructor() {
+        super(...arguments);
+        this.name = 'fs_delete_file';
+        this.description = 'Delete a file or directory';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'The absolute path to the file or directory to delete'
+                },
+                recursive: {
+                    type: 'boolean',
+                    description: 'Whether to delete recursively (for directories). Default: false'
+                }
+            },
+            required: ['path']
+        };
+    }
+    async execute(params) {
+        const filePath = path.resolve(params.path);
+        const recursive = params.recursive || false;
+        try {
+            const stats = await fs.stat(filePath);
+            if (stats.isDirectory()) {
+                await fs.rm(filePath, { recursive, force: true });
+            }
+            else {
+                await fs.unlink(filePath);
+            }
+            return `Successfully deleted ${filePath}`;
+        }
+        catch (error) {
+            return `Error deleting file: ${error.message}`;
+        }
+    }
+}

package/dist/server/skills/list-agents.js

@@ -0,0 +1,24 @@
+import { BaseSkill } from '../skills/base-skill.js';
+import { agentManager } from '../core/agents/manager.js';
+export class ListAgentsSkill extends BaseSkill {
+    constructor() {
+        super(...arguments);
+        this.name = 'list_agents';
+        this.description = 'List all available agents and their descriptions.';
+        this.parameters = {
+            type: 'object',
+            properties: {},
+            required: []
+        };
+    }
+    async execute() {
+        const agents = agentManager.getAllAgents();
+        return {
+            agents: agents.map(a => ({
+                name: a.name,
+                description: a.description,
+                tools: a.getToolsDefinition().map(t => t.function.name)
+            }))
+        };
+    }
+}

package/dist/server/skills/office-excel.js

@@ -0,0 +1,84 @@
+import { BaseSkill } from './base-skill.js';
+import xlsx from 'xlsx';
+import fs from 'fs';
+export class ReadExcelSkill extends BaseSkill {
+    constructor() {
+        super(...arguments);
+        this.name = 'read_excel_file';
+        this.description = 'Read data from a Microsoft Excel (.xlsx) file as JSON';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The absolute path to the .xlsx file'
+                },
+                sheet_name: {
+                    type: 'string',
+                    description: 'Optional: specific sheet name to read. If omitted, reads the first sheet.'
+                }
+            },
+            required: ['file_path']
+        };
+    }
+    async execute(args) {
+        try {
+            if (!fs.existsSync(args.file_path)) {
+                return { error: `File not found: ${args.file_path}` };
+            }
+            const workbook = xlsx.readFile(args.file_path);
+            const sheetName = args.sheet_name || workbook.SheetNames[0];
+            if (!workbook.Sheets[sheetName]) {
+                return { error: `Sheet "${sheetName}" not found. Available sheets: ${workbook.SheetNames.join(', ')}` };
+            }
+            const sheet = workbook.Sheets[sheetName];
+            const data = xlsx.utils.sheet_to_json(sheet);
+            return {
+                sheet: sheetName,
+                data: data
+            };
+        }
+        catch (error) {
+            return { error: `Failed to read Excel file: ${error.message}` };
+        }
+    }
+}
+export class CreateExcelSkill extends BaseSkill {
+    constructor() {
+        super(...arguments);
+        this.name = 'create_excel_file';
+        this.description = 'Create a new Microsoft Excel (.xlsx) file with data';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The absolute path where the .xlsx file should be saved'
+                },
+                data: {
+                    type: 'array',
+                    items: { type: 'object' },
+                    description: 'Array of objects representing rows of data'
+                },
+                sheet_name: {
+                    type: 'string',
+                    description: 'Optional: name of the sheet. Defaults to "Sheet1".'
+                }
+            },
+            required: ['file_path', 'data']
+        };
+    }
+    async execute(args) {
+        try {
+            const workbook = xlsx.utils.book_new();
+            const sheet = xlsx.utils.json_to_sheet(args.data);
+            const sheetName = args.sheet_name || 'Sheet1';
+            xlsx.utils.book_append_sheet(workbook, sheet, sheetName);
+            xlsx.writeFile(workbook, args.file_path);
+            return { success: true, message: `Excel file created at ${args.file_path}` };
+        }
+        catch (error) {
+            return { error: `Failed to create Excel file: ${error.message}` };
+        }
+    }
+}

package/dist/server/skills/office-ppt.js

@@ -0,0 +1,58 @@
+import { BaseSkill } from './base-skill.js';
+import pptxgen from 'pptxgenjs';
+export class CreatePptxSkill extends BaseSkill {
+    constructor() {
+        super(...arguments);
+        this.name = 'create_pptx_file';
+        this.description = 'Create a new Microsoft PowerPoint (.pptx) file with slides';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The absolute path where the .pptx file should be saved'
+                },
+                slides: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            title: { type: 'string' },
+                            content: { type: 'string' } // Simple text content for now
+                        }
+                    },
+                    description: 'Array of slide objects with title and content'
+                },
+                author: {
+                    type: 'string',
+                    description: 'Optional author name'
+                }
+            },
+            required: ['file_path', 'slides']
+        };
+    }
+    async execute(args) {
+        try {
+            // Handle different import styles (ESM/CJS interop)
+            const PptxGenJS = pptxgen.default || pptxgen;
+            const pres = new PptxGenJS();
+            if (args.author) {
+                pres.author = args.author;
+            }
+            for (const slideData of args.slides) {
+                const slide = pres.addSlide();
+                if (slideData.title) {
+                    slide.addText(slideData.title, { x: 1, y: 1, w: '80%', h: 1, fontSize: 24, align: 'center', bold: true });
+                }
+                if (slideData.content) {
+                    slide.addText(slideData.content, { x: 1, y: 2.5, w: '80%', h: 3, fontSize: 18 });
+                }
+            }
+            await pres.writeFile({ fileName: args.file_path });
+            return { success: true, message: `PowerPoint file created at ${args.file_path}` };
+        }
+        catch (error) {
+            return { error: `Failed to create PowerPoint file: ${error.message}` };
+        }
+    }
+}

package/dist/server/skills/office-word.js

@@ -0,0 +1,90 @@
+import { BaseSkill } from './base-skill.js';
+import mammoth from 'mammoth';
+import officegen from 'officegen';
+import fs from 'fs';
+export class ReadWordSkill extends BaseSkill {
+    constructor() {
+        super(...arguments);
+        this.name = 'read_word_file';
+        this.description = 'Read text content from a Microsoft Word (.docx) file';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The absolute path to the .docx file'
+                }
+            },
+            required: ['file_path']
+        };
+    }
+    async execute(args) {
+        try {
+            if (!fs.existsSync(args.file_path)) {
+                return { error: `File not found: ${args.file_path}` };
+            }
+            const result = await mammoth.extractRawText({ path: args.file_path });
+            return { content: result.value };
+        }
+        catch (error) {
+            return { error: `Failed to read Word file: ${error.message}` };
+        }
+    }
+}
+export class CreateWordSkill extends BaseSkill {
+    constructor() {
+        super(...arguments);
+        this.name = 'create_word_file';
+        this.description = 'Create a new Microsoft Word (.docx) file with text content';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The absolute path where the .docx file should be saved'
+                },
+                content: {
+                    type: 'string',
+                    description: 'The text content to write into the document'
+                },
+                title: {
+                    type: 'string',
+                    description: 'Optional title for the document'
+                }
+            },
+            required: ['file_path', 'content']
+        };
+    }
+    async execute(args) {
+        return new Promise((resolve, reject) => {
+            try {
+                const docx = officegen('docx');
+                docx.on('error', (err) => {
+                    resolve({ error: `Officegen error: ${err}` });
+                });
+                if (args.title) {
+                    const pObj = docx.createP();
+                    pObj.addText(args.title, { bold: true, font_size: 24 });
+                }
+                const paragraphs = args.content.split('\n');
+                for (const para of paragraphs) {
+                    if (para.trim()) {
+                        const pObj = docx.createP();
+                        pObj.addText(para);
+                    }
+                }
+                const out = fs.createWriteStream(args.file_path);
+                out.on('error', (err) => {
+                    resolve({ error: `File write error: ${err}` });
+                });
+                out.on('close', () => {
+                    resolve({ success: true, message: `Word file created at ${args.file_path}` });
+                });
+                docx.generate(out);
+            }
+            catch (error) {
+                resolve({ error: `Failed to create Word file: ${error.message}` });
+            }
+        });
+    }
+}

package/dist/server/skills/registry.js

@@ -0,0 +1,27 @@
+class SkillRegistry {
+    constructor() {
+        this.skills = new Map();
+    }
+    static getInstance() {
+        if (!SkillRegistry.instance) {
+            SkillRegistry.instance = new SkillRegistry();
+        }
+        return SkillRegistry.instance;
+    }
+    register(skill) {
+        if (this.skills.has(skill.name)) {
+            console.warn(`Skill ${skill.name} is already registered. Overwriting.`);
+        }
+        this.skills.set(skill.name, skill);
+    }
+    getSkill(name) {
+        return this.skills.get(name);
+    }
+    getAllSkills() {
+        return Array.from(this.skills.values());
+    }
+    getToolsDefinition() {
+        return this.getAllSkills().map(skill => skill.toJSON());
+    }
+}
+export const skillRegistry = SkillRegistry.getInstance();

package/dist/server/skills/search.js

@@ -0,0 +1,31 @@
+import { BaseSkill } from './base-skill.js';
+export class SearchSkill extends BaseSkill {
+    constructor() {
+        super(...arguments);
+        this.name = 'web_search';
+        this.description = 'Search the web for information';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The search query'
+                }
+            },
+            required: ['query']
+        };
+    }
+    async execute(params) {
+        const { query } = params;
+        // 这里可以集成真实的搜索 API，如 Google Search API 或 SerpApi
+        // 为了简化，我们返回一个模拟结果
+        return {
+            results: [
+                {
+                    title: `Result for ${query}`,
+                    snippet: `This is a simulated search result for "${query}". In a real implementation, this would call a search engine API.`
+                }
+            ]
+        };
+    }
+}

package/dist/server/skills/system-time.js

@@ -0,0 +1,27 @@
+import { BaseSkill } from './base-skill.js';
+export class SystemTimeSkill extends BaseSkill {
+    constructor() {
+        super(...arguments);
+        this.name = 'get_system_time';
+        this.description = 'Get the current system time';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                format: {
+                    type: 'string',
+                    description: 'The format of the time (e.g., "iso", "locale")',
+                    enum: ['iso', 'locale']
+                }
+            },
+            required: []
+        };
+    }
+    async execute(params) {
+        const format = params.format || 'iso';
+        const now = new Date();
+        if (format === 'locale') {
+            return now.toLocaleString();
+        }
+        return now.toISOString();
+    }
+}