@byted-las/contextlake-openclaw 1.0.0

package/dist/src/commands/index.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAll = registerAll;
+const tools_1 = require("./tools");
+const cli_1 = require("./cli");
+const slashcmd_1 = require("./slashcmd");
+const config_1 = require("../utils/config");
+const las_data_profiler_1 = require("../skills/las-data-profiler");
+function registerAll(ctx, logger) {
+    const pluginConfig = (0, config_1.getPluginConfig)(ctx);
+    // Register Agent Tools
+    try {
+        const tools = (0, tools_1.getAgentTools)(pluginConfig, logger);
+        ctx.registerTool(tools.ingestTool);
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.ingestTool.name}`);
+        ctx.registerTool(tools.retrieveTool);
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.retrieveTool.name}`);
+        ctx.registerTool(tools.listTool);
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.listTool.name}`);
+        ctx.registerTool(tools.deleteTool);
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.deleteTool.name}`);
+    }
+    catch (error) {
+        logger.error(`[${new Date().toISOString()}] [ContextLake] Error registering agent tools: ${error.message}`, { stack: error.stack });
+        throw error;
+    }
+    // Register CLI
+    try {
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Registering CLI commands`);
+        ctx.registerCli((cliContext) => {
+            const program = cliContext.program;
+            const contextlake = program.command('contextlake')
+                .description('Manage ContextLake knowledge base');
+            const commands = (0, cli_1.getCliCommands)(pluginConfig, logger);
+            // connect -- data source profiling (las-data-profiler)
+            contextlake.command('connect <datasource_name>')
+                .description('Connect to a data source and profile its structure, schemas, and media metadata into LanceDB')
+                .requiredOption('--vendor <vendor>', 'Data source type: volcengine | alibaba | tencent | aws | local')
+                .option('--endpoint <url>', 'S3 Endpoint URL (not needed for local)')
+                .option('--ak <credential_id>', 'Credential ID for the data source')
+                .option('--sk <credential_value>', 'Credential value for the data source')
+                .option('--region <region>', 'Region identifier (e.g. cn-beijing)')
+                .requiredOption('--bucket <bucket>', 'Bucket name (or local root directory for local vendor)')
+                .requiredOption('--prefix <prefix>', 'Path prefix to limit scan scope')
+                .option('--sample-rows <number>', 'Number of rows to sample per structured file', '100')
+                .action(async (datasource_name, options) => {
+                try {
+                    const params = {
+                        datasource_name,
+                        vendor: options.vendor,
+                        endpoint: options.endpoint,
+                        access_key: options.ak,
+                        secret_key: options.sk,
+                        region: options.region,
+                        bucket: options.bucket,
+                        prefix: options.prefix,
+                        sample_rows: parseInt(options.sampleRows),
+                    };
+                    console.log(`[contextlake connect] Connecting to datasource "${datasource_name}"...`);
+                    console.log(`  vendor: ${params.vendor}`);
+                    console.log(`  bucket: ${params.bucket}`);
+                    console.log(`  prefix: ${params.prefix}`);
+                    const result = await (0, las_data_profiler_1.connectDataSource)(params);
+                    console.log(JSON.stringify(result, null, 2));
+                }
+                catch (e) {
+                    console.error('Error:', e.message);
+                    process.exitCode = 1;
+                }
+            });
+            // Ingest
+            contextlake.command('ingest <files...>')
+                .description('Ingest one or more files into the knowledge base')
+                .option('-c, --chunk-size <number>', 'Chunk size for text splitting', '500')
+                .option('-o, --overlap <number>', 'Chunk overlap size', '50')
+                .option('-m, --metadata <json>', 'JSON metadata to attach to the documents')
+                .action(commands.ingestAction);
+            // Search
+            contextlake.command('search <query>')
+                .description('Search the knowledge base for relevant documents')
+                .option('-k, --top-k <number>', 'Number of top results to return', '5')
+                .option('-f, --filter <string>', 'Filter string for the search')
+                .option('-b, --binary', 'Include binary content in the result', false)
+                .action(commands.searchAction);
+            // List
+            contextlake.command('list')
+                .description('List documents currently in the knowledge base')
+                .option('-l, --limit <number>', 'Maximum number of results to return', '100')
+                .action(commands.listAction);
+            // Delete
+            contextlake.command('delete')
+                .description('Delete documents from the knowledge base')
+                .option('--ids <ids...>', 'List of specific file IDs to delete')
+                .option('-f, --filter <string>', 'Filter string to match documents for deletion')
+                .action(commands.deleteAction);
+        }, { commands: ['contextlake'] });
+        logger.info(`[${new Date().toISOString()}] [ContextLake] CLI commands registered`);
+    }
+    catch (error) {
+        logger.error(`[${new Date().toISOString()}] [ContextLake] Error registering CLI commands: ${error.message}`, { stack: error.stack });
+        throw error;
+    }
+    // Register Slash Commands
+    try {
+        if (typeof ctx.registerCommand !== 'function') {
+            logger.warn(`[ContextLake] registerCommand is not available in current OpenClaw version, skipping slash commands registration.`);
+            return;
+        }
+        const slashCommands = (0, slashcmd_1.getSlashCommands)(pluginConfig, logger);
+        ctx.registerCommand({
+            name: 'contextlake-ingest',
+            description: 'Ingest files into the knowledge base (usage: /contextlake-ingest file1 file2)',
+            acceptsArgs: true,
+            handler: slashCommands.ingestHandler
+        });
+        ctx.registerCommand({
+            name: 'contextlake-list',
+            description: 'List documents currently in the knowledge base',
+            acceptsArgs: true,
+            handler: slashCommands.listHandler
+        });
+        ctx.registerCommand({
+            name: 'contextlake-search',
+            description: 'Search the knowledge base for relevant documents',
+            acceptsArgs: true,
+            handler: slashCommands.searchHandler
+        });
+        ctx.registerCommand({
+            name: 'contextlake-delete',
+            description: 'Delete documents from the knowledge base by ID',
+            acceptsArgs: true,
+            handler: slashCommands.deleteHandler
+        });
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Slash commands registered`);
+    }
+    catch (error) {
+        logger.error(`[${new Date().toISOString()}] [ContextLake] Error registering Slash commands: ${error.message}`, { stack: error.stack });
+    }
+}

package/dist/src/commands/slashcmd.d.ts

@@ -0,0 +1,14 @@
+export declare function getSlashCommands(pluginConfig: any, logger: any): {
+    ingestHandler: (commandCtx: any) => Promise<{
+        text: string;
+    }>;
+    listHandler: (commandCtx: any) => Promise<{
+        text: string;
+    }>;
+    searchHandler: (commandCtx: any) => Promise<{
+        text: string;
+    }>;
+    deleteHandler: (commandCtx: any) => Promise<{
+        text: string;
+    }>;
+};

package/dist/src/commands/slashcmd.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSlashCommands = getSlashCommands;
+const ingest_1 = require("../lib/actions/ingest");
+const retrieve_1 = require("../lib/actions/retrieve");
+const manage_1 = require("../lib/actions/manage");
+function getSlashCommands(pluginConfig, logger) {
+    return {
+        ingestHandler: async (commandCtx) => {
+            const rawArgs = commandCtx.args || "";
+            const args = rawArgs.split(' ').filter((arg) => arg.trim() !== '');
+            logger.info(`[${new Date().toISOString()}] [ContextLake] Slash command ingest started`, { args });
+            try {
+                if (args.length === 0) {
+                    return { text: `**Error:** Missing files. Usage: /contextlake-ingest /path/to/file1 /path/to/file2` };
+                }
+                const result = await (0, ingest_1.ingestAssets)({
+                    files: args,
+                    metadata: {}
+                }, pluginConfig, logger);
+                logger.info(`[${new Date().toISOString()}] [ContextLake] Slash command ingest completed`, { resultCount: result.length });
+                return { text: `**Ingest Results (${result.length} files processed):**\n\`\`\`json\n${JSON.stringify(result, null, 2)}\n\`\`\`` };
+            }
+            catch (e) {
+                logger.error(`[ContextLake] Slash ingest failed`, { error: e.message });
+                return { text: `**Error executing ingest:** ${e.message}` };
+            }
+        },
+        listHandler: async (commandCtx) => {
+            const rawArgs = commandCtx.args || "";
+            const args = rawArgs.split(' ').filter((arg) => arg.trim() !== '');
+            logger.info(`[${new Date().toISOString()}] [ContextLake] Slash command list started`, { args });
+            try {
+                let limit = 100;
+                if (args.length > 0 && !isNaN(parseInt(args[0]))) {
+                    limit = parseInt(args[0]);
+                }
+                const result = await (0, manage_1.listAssets)({ limit }, pluginConfig, logger);
+                logger.info(`[${new Date().toISOString()}] [ContextLake] Slash command list completed`, { resultCount: result.length });
+                return { text: `**ContextLake Documents (${result.length}):**\n\`\`\`json\n${JSON.stringify(result, null, 2)}\n\`\`\`` };
+            }
+            catch (e) {
+                logger.error(`[ContextLake] Slash list failed`, { error: e.message });
+                return { text: `**Error executing list:** ${e.message}` };
+            }
+        },
+        searchHandler: async (commandCtx) => {
+            const rawArgs = commandCtx.args || "";
+            const args = rawArgs.split(' ').filter((arg) => arg.trim() !== '');
+            logger.info(`[${new Date().toISOString()}] [ContextLake] Slash command search started`, { args });
+            try {
+                if (args.length === 0) {
+                    return { text: `**Error:** Missing search query. Usage: /contextlake-search "your query here"` };
+                }
+                const query = args.join(' ');
+                const result = await (0, retrieve_1.retrieveAssets)({
+                    query,
+                    top_k: 5,
+                    filter: undefined,
+                    include_binary: false
+                }, pluginConfig, logger);
+                logger.info(`[${new Date().toISOString()}] [ContextLake] Slash command search completed`, { resultCount: result.length });
+                return { text: `**Search Results for "${query}" (${result.length}):**\n\`\`\`json\n${JSON.stringify(result, null, 2)}\n\`\`\`` };
+            }
+            catch (e) {
+                logger.error(`[ContextLake] Slash search failed`, { error: e.message });
+                return { text: `**Error executing search:** ${e.message}` };
+            }
+        },
+        deleteHandler: async (commandCtx) => {
+            const rawArgs = commandCtx.args || "";
+            const args = rawArgs.split(' ').filter((arg) => arg.trim() !== '');
+            logger.info(`[${new Date().toISOString()}] [ContextLake] Slash command delete started`, { args });
+            try {
+                if (args.length === 0) {
+                    return { text: `**Error:** Missing file IDs. Usage: /contextlake-delete fileId1 fileId2` };
+                }
+                const result = await (0, manage_1.deleteAssets)({
+                    file_ids: args,
+                    filter: undefined
+                }, pluginConfig, logger);
+                logger.info(`[${new Date().toISOString()}] [ContextLake] Slash command delete completed`, { result });
+                return { text: `**Delete Results:**\n\`\`\`json\n${JSON.stringify(result, null, 2)}\n\`\`\`` };
+            }
+            catch (e) {
+                logger.error(`[ContextLake] Slash delete failed`, { error: e.message });
+                return { text: `**Error executing delete:** ${e.message}` };
+            }
+        }
+    };
+}

package/dist/src/commands/tools.d.ts

@@ -0,0 +1,219 @@
+export declare function getAgentTools(pluginConfig: any, logger: any): {
+    ingestTool: {
+        name: string;
+        label: string;
+        description: string;
+        parameters: {
+            type: string;
+            properties: {
+                files: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    description: string;
+                };
+                metadata: {
+                    type: string;
+                    description: string;
+                    additionalProperties: boolean;
+                };
+                chunkSize: {
+                    type: string;
+                    description: string;
+                };
+                overlap: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        schema: {
+            type: string;
+            properties: {
+                files: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    description: string;
+                };
+                metadata: {
+                    type: string;
+                    description: string;
+                    additionalProperties: boolean;
+                };
+                chunkSize: {
+                    type: string;
+                    description: string;
+                };
+                overlap: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        execute(toolCallId: string, params: any): Promise<{
+            success: boolean;
+            result: any;
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: any;
+            result?: undefined;
+        }>;
+    };
+    retrieveTool: {
+        name: string;
+        label: string;
+        description: string;
+        parameters: {
+            type: string;
+            properties: {
+                query: {
+                    type: string;
+                    description: string;
+                };
+                top_k: {
+                    type: string;
+                    description: string;
+                };
+                filter: {
+                    type: string;
+                    description: string;
+                };
+                include_binary: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        schema: {
+            type: string;
+            properties: {
+                query: {
+                    type: string;
+                    description: string;
+                };
+                top_k: {
+                    type: string;
+                    description: string;
+                };
+                filter: {
+                    type: string;
+                    description: string;
+                };
+                include_binary: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        execute(toolCallId: string, params: any): Promise<{
+            success: boolean;
+            result: any[];
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: any;
+            result?: undefined;
+        }>;
+    };
+    listTool: {
+        name: string;
+        label: string;
+        description: string;
+        parameters: {
+            type: string;
+            properties: {
+                limit: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: never[];
+            additionalProperties: boolean;
+        };
+        schema: {
+            type: string;
+            properties: {
+                limit: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: never[];
+        };
+        execute(toolCallId: string, params: any): Promise<{
+            success: boolean;
+            result: any;
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: any;
+            result?: undefined;
+        }>;
+    };
+    deleteTool: {
+        name: string;
+        label: string;
+        description: string;
+        parameters: {
+            type: string;
+            properties: {
+                file_ids: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    description: string;
+                };
+                filter: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: never[];
+            additionalProperties: boolean;
+        };
+        schema: {
+            type: string;
+            properties: {
+                file_ids: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    description: string;
+                };
+                filter: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: never[];
+        };
+        execute(toolCallId: string, params: any): Promise<{
+            success: boolean;
+            result: {
+                status: string;
+                message: string;
+                deleted_count: number;
+                storage_cleaned: number;
+            };
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: any;
+            result?: undefined;
+        }>;
+    };
+};