xiaozuoassistant 0.2.19 → 0.2.21

package/dist/server/llm/openai.js

@@ -0,0 +1,23 @@
+import OpenAI from 'openai';
+export function resolveBaseURL(config) {
+    switch (config.provider) {
+        case 'deepseek':
+            return 'https://api.deepseek.com';
+        case 'minimax':
+            return 'https://api.minimax.chat/v1';
+        case 'doubao':
+            return 'https://ark.cn-beijing.volces.com/api/v3';
+        case 'qwen':
+            return 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1';
+        case 'custom':
+        case 'openai':
+        default:
+            return config.baseURL;
+    }
+}
+export function createOpenAIClient(config) {
+    return new OpenAI({
+        apiKey: config.apiKey || '',
+        baseURL: resolveBaseURL(config)
+    });
+}

package/dist/server/plugins/core-skills/src/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, _ctx) {
+        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/plugins/core-skills/src/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, _ctx) {
+        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/plugins/core-skills/src/file-system.js

@@ -0,0 +1,142 @@
+import { BaseSkill } from '../../../skills/base-skill.js';
+import fs from 'fs/promises';
+import path from 'path';
+import { resolvePathWithinWorkspace, resolveSessionWorkspace } from '../../../config/paths.js';
+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: 'Absolute path, or relative to the current session workspace. Defaults to the session workspace.'
+                }
+            },
+            required: []
+        };
+    }
+    async execute(params, ctx) {
+        const workspace = resolveSessionWorkspace(ctx);
+        const dirPath = params.path ? resolvePathWithinWorkspace(workspace, String(params.path)) : workspace;
+        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: 'Absolute path, or relative to the current session workspace.'
+                },
+                encoding: {
+                    type: 'string',
+                    description: 'The encoding to use (default: utf-8)',
+                    enum: ['utf-8', 'base64']
+                }
+            },
+            required: ['path']
+        };
+    }
+    async execute(params, ctx) {
+        const workspace = resolveSessionWorkspace(ctx);
+        const filePath = resolvePathWithinWorkspace(workspace, String(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: 'Absolute path, or relative to the current session workspace.'
+                },
+                content: {
+                    type: 'string',
+                    description: 'The content to write to the file'
+                }
+            },
+            required: ['path', 'content']
+        };
+    }
+    async execute(params, ctx) {
+        const workspace = resolveSessionWorkspace(ctx);
+        const filePath = resolvePathWithinWorkspace(workspace, String(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: 'Absolute path, or relative to the current session workspace.'
+                },
+                recursive: {
+                    type: 'boolean',
+                    description: 'Whether to delete recursively (for directories). Default: false'
+                }
+            },
+            required: ['path']
+        };
+    }
+    async execute(params, ctx) {
+        const workspace = resolveSessionWorkspace(ctx);
+        const filePath = resolvePathWithinWorkspace(workspace, String(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/plugins/core-skills/src/index.js

@@ -0,0 +1,26 @@
+import { ListDirectorySkill, ReadFileSkill, WriteFileSkill, DeleteFileSkill } from './file-system.js';
+import { SearchSkill } from './search.js';
+import { SystemTimeSkill } from './system-time.js';
+import { CreateAgentSkill } from './create-agent.js';
+import { DelegateSkill } from './delegate.js';
+import { ListAgentsSkill } from './list-agents.js';
+const plugin = {
+    metadata: {
+        name: 'core-skills',
+        version: '1.0.0',
+        description: 'Core system skills for XiaoZuoClaw',
+        author: 'XiaoZuoClaw Team'
+    },
+    onLoad: (context) => {
+        context.registerSkill(new ListDirectorySkill());
+        context.registerSkill(new ReadFileSkill());
+        context.registerSkill(new WriteFileSkill());
+        context.registerSkill(new DeleteFileSkill());
+        context.registerSkill(new SearchSkill());
+        context.registerSkill(new SystemTimeSkill());
+        context.registerSkill(new CreateAgentSkill());
+        context.registerSkill(new DelegateSkill());
+        context.registerSkill(new ListAgentsSkill());
+    }
+};
+export default plugin;

package/dist/server/plugins/core-skills/src/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(_params, _ctx) {
+        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/plugins/core-skills/src/search.js

@@ -0,0 +1,31 @@
+import { BaseSkill } from '../../../skills/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, _ctx) {
+        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/plugins/core-skills/src/system-time.js

@@ -0,0 +1,27 @@
+import { BaseSkill } from '../../../skills/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, _ctx) {
+        const format = params.format || 'iso';
+        const now = new Date();
+        if (format === 'locale') {
+            return now.toLocaleString();
+        }
+        return now.toISOString();
+    }
+}

package/dist/server/plugins/office-skills/src/index.js

@@ -0,0 +1,19 @@
+import { ReadWordSkill, CreateWordSkill } from './office-word.js';
+import { ReadExcelSkill, CreateExcelSkill } from './office-excel.js';
+import { CreatePptxSkill } from './office-ppt.js';
+const plugin = {
+    metadata: {
+        name: 'office-skills',
+        version: '1.0.0',
+        description: 'Microsoft Office integration skills (Word, Excel, PowerPoint)',
+        author: 'XiaoZuoClaw Team'
+    },
+    onLoad: (context) => {
+        context.registerSkill(new ReadWordSkill());
+        context.registerSkill(new CreateWordSkill());
+        context.registerSkill(new ReadExcelSkill());
+        context.registerSkill(new CreateExcelSkill());
+        context.registerSkill(new CreatePptxSkill());
+    }
+};
+export default plugin;

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

@@ -0,0 +1,84 @@
+import { BaseSkill } from '../../../skills/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, _ctx) {
+        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, _ctx) {
+        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/plugins/office-skills/src/office-ppt.js

@@ -0,0 +1,58 @@
+import { BaseSkill } from '../../../skills/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, _ctx) {
+        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/plugins/office-skills/src/office-word.js

@@ -0,0 +1,90 @@
+import { BaseSkill } from '../../../skills/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, _ctx) {
+        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, _ctx) {
+        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/routes/auth.js

@@ -0,0 +1,28 @@
+/**
+ * This is a user authentication API route demo.
+ * Handle user registration, login, token management, etc.
+ */
+import { Router } from 'express';
+const router = Router();
+/**
+ * User Login
+ * POST /api/auth/register
+ */
+router.post('/register', async (req, res) => {
+    // TODO: Implement register logic
+});
+/**
+ * User Login
+ * POST /api/auth/login
+ */
+router.post('/login', async (req, res) => {
+    // TODO: Implement login logic
+});
+/**
+ * User Logout
+ * POST /api/auth/logout
+ */
+router.post('/logout', async (req, res) => {
+    // TODO: Implement logout logic
+});
+export default router;