@byted-las/contextlake-openclaw 1.0.3 → 1.0.5

package/README.md

@@ -1,27 +1,32 @@
 # ContextLake OpenClaw Plugin
 
-A powerful, serverless-first Knowledge Base / Knowledge Lake (知识库/知识湖) plugin for the OpenClaw Agent framework.
+A powerful, multi-modal Knowledge Base / Knowledge Lake (知识库/知识湖) plugin for the OpenClaw Agent framework.
 
-This plugin allows OpenClaw agents to natively understand, index, and retrieve local and remote documents (PDF, Word, Markdown, Text) using vector similarity search. It features a pluggable architecture supporting both completely offline operations (via LanceDB and local GGUF models) and cloud-based operations.
+This plugin allows OpenClaw agents to natively understand, profile, index, and retrieve data from diverse data sources (Local, TOS, S3, etc.). It supports advanced multi-modal document ingestion (Text, PDF, Images, Audio, Video) powered by Large AI Services (LAS) and vector similarity search.
 
 ## Features
 
-- **Multi-modal Document Ingestion**: Automatically extracts text from PDF, DOCX, TXT, and MD files.
-- **Agentic Tools**: Exposes `contextlake-ingest`, `contextlake-retrieve`, `contextlake-list`, and `contextlake-delete` skills directly to the LLM.
-- **Slash Commands**: Quick chat actions (`/contextlake-search`, `/contextlake-ingest`) for fast human-in-the-loop operations.
-- **CLI Management**: Full command-line interface for bulk operations and CI/CD integration.
-- **Local-First & Pluggable**: 
-  - Uses `LanceDB` for local embedded vector storage.
-  - Uses `node-llama-cpp` for offline, private embedding generation (`bge-small-zh` by default).
-  - Can be easily configured to use remote embedding APIs (like OpenAI or Doubao ARK) or remote storage (TOS).
+- **Data Profiling**: Connect to heterogeneous data sources (TOS/OSS/COS/S3/Local) and auto-profile schemas and media metadata.
+- **Multi-modal Ingestion**: Automatically extracts text, converts PDFs, parses audio (ASR), understands video, and embeds images directly using LAS multi-modal models.
+- **Agentic Tools**: Exposes `contextlake-ingest`, `contextlake-retrieve`, `contextlake-list`, `contextlake-delete`, `las-data-profiler`, and `contextlake-list-datasource` skills directly to the LLM.
+- **Slash Commands**: Quick chat actions (`/contextlake-search`, `/contextlake-ingest`, `/contextlake-profiler`) for fast human-in-the-loop operations.
+- **CLI Management**: Full command-line interface for bulk operations and pipeline integration.
+- **Pluggable Architecture**: 
+  - Uses `LanceDB` for local embedded multi-modal vector storage.
+  - Pluggable storage providers (Local and TOS).
+
+## Documentation
+
+For a comprehensive guide on installation, initialization (`onboard`), connecting data sources (`connect`/`profiler`), ingestion, and searching, please refer to the [**USAGE.md**](./USAGE.md).
+
+For detailed architecture and internal workflows, please refer to [AGENTS.md](./AGENTS.md).
 
 ## Installation
 
 Assuming you are in an OpenClaw environment:
 
 ```bash
-npm install
-npm run build
+npm install @byted-las/contextlake-openclaw
 ```
 
 Then register the plugin in your OpenClaw configuration:
@@ -30,7 +35,7 @@ Then register the plugin in your OpenClaw configuration:
 {
   "plugins": [
     {
-      "package": "contextlake-openclaw",
+      "package": "@byted-las/contextlake-openclaw",
       "config": {
         "metadata_storage": {
           "type": "local",
@@ -46,19 +51,36 @@ Then register the plugin in your OpenClaw configuration:
 }
 ```
 
+## Quick Start (Slash Commands)
+
+1. **Initialize Credentials** (Run in terminal):
+   ```bash
+   openclaw contextlake onboard
+   ```
+2. **Profile a Data Source**:
+   ```text
+   /contextlake-profiler my_data local /path/to/my/files .
+   ```
+3. **Ingest the Data Source** (Processes PDF, Audio, Images, Text):
+   ```text
+   /contextlake-ingest my_data
+   ```
+4. **Search your Knowledge Base**:
+   ```text
+   /contextlake-search How do I configure the API?
+   ```
+
 ## Agent Tools (Skills)
 
 The LLM agent automatically has access to the following tools:
 
-1. **`contextlake-ingest`**: Uploads and indexes files.
-2. **`contextlake-retrieve`**: Performs vector search on the indexed documents based on a query.
-3. **`contextlake-list`**: Lists all currently indexed documents.
-4. **`contextlake-delete`**: Removes documents by ID or filter.
+1. **`las-data-profiler`**: Connect to a data source and profile its structure.
+2. **`contextlake-list-datasource`**: List all connected and profiled data sources.
+3. **`contextlake-ingest`**: Process and ingest all profiled files into the knowledge base via multi-modal embeddings.
+4. **`contextlake-retrieve`**: Performs vector search on the indexed documents based on a query.
+5. **`contextlake-list`**: Lists all currently indexed documents.
+6. **`contextlake-delete`**: Removes documents by ID or filter.
 
 You can simply talk to the agent:
-> "帮我把这个 `manual.pdf` 注入到知识库中。"
-> "在知识湖中检索关于架构设计的文档。"
-
-## Development
-
-For detailed architecture and internal workflows, please refer to [AGENTS.md](./AGENTS.md).
+> "帮我把 `my_data` 数据源注入到知识库中。"
+> "在知识湖中检索关于架构设计的文档。"

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

@@ -1,6 +1,6 @@
 import { ContextLakeConfig } from '../utils/config';
 export declare function getCliCommands(pluginConfig: ContextLakeConfig, logger: any): {
-    connectAction: (datasource_name: string, options: any) => Promise<void>;
+    connectAction: (datasource_name: string, url: string, options: any) => Promise<void>;
     ingestAction: (datasource_name: string) => Promise<void>;
     searchAction: (query: any, options: any) => Promise<void>;
     listAction: (options: any) => Promise<void>;

package/dist/src/commands/cli.js

@@ -34,28 +34,22 @@ function parseMetadata(metadata) {
 }
 function getCliCommands(pluginConfig, logger) {
     return {
-        connectAction: async (datasource_name, options) => {
-            logger.info(`[${new Date().toISOString()}] [ContextLake] CLI connect started`, { datasource_name, options });
+        connectAction: async (datasource_name, url, options) => {
+            logger.info(`[${new Date().toISOString()}] [ContextLake] CLI connect started`, { datasource_name, url, options });
             try {
                 const params = {
                     datasource_name,
-                    vendor: options.vendor,
+                    url,
                     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),
                 };
                 // eslint-disable-next-line no-console
                 console.log(`[contextlake connect] Connecting to datasource "${datasource_name}"...`);
                 // eslint-disable-next-line no-console
-                console.log(`  vendor: ${params.vendor}`);
-                // eslint-disable-next-line no-console
-                console.log(`  bucket: ${params.bucket}`);
-                // eslint-disable-next-line no-console
-                console.log(`  prefix: ${params.prefix}`);
+                console.log(`  url: ${params.url}`);
                 const result = await (0, profiler_1.connectDataSource)(params);
                 // eslint-disable-next-line no-console
                 console.log(JSON.stringify(result, null, 2));
@@ -141,12 +135,14 @@ function getCliCommands(pluginConfig, logger) {
                 // eslint-disable-next-line no-console
                 console.log('Please provide your credentials below. Press enter to keep the current value.');
                 const lasApiKey = await (0, credentials_1.promptForInput)('LAS_API_KEY', currentCreds.LAS_API_KEY);
-                const volcengineAccessKey = await (0, credentials_1.promptForInput)('VOLCENGINE_ACCESS_KEY', currentCreds.VOLCENGINE_ACCESS_KEY);
-                const volcengineSecretKey = await (0, credentials_1.promptForInput)('VOLCENGINE_SECRET_KEY', currentCreds.VOLCENGINE_SECRET_KEY);
+                const accessKey = await (0, credentials_1.promptForInput)('ACCESS_KEY', currentCreds.ACCESS_KEY || currentCreds.VOLCENGINE_ACCESS_KEY);
+                const secretKey = await (0, credentials_1.promptForInput)('SECRET_KEY', currentCreds.SECRET_KEY || currentCreds.VOLCENGINE_SECRET_KEY);
+                const region = await (0, credentials_1.promptForInput)('REGION', currentCreds.REGION || currentCreds.VOLCENGINE_REGION || 'cn-beijing');
                 const newCreds = {
                     LAS_API_KEY: lasApiKey,
-                    VOLCENGINE_ACCESS_KEY: volcengineAccessKey,
-                    VOLCENGINE_SECRET_KEY: volcengineSecretKey
+                    ACCESS_KEY: accessKey,
+                    SECRET_KEY: secretKey,
+                    REGION: region
                 };
                 (0, credentials_1.saveCredentials)(newCreds);
                 // eslint-disable-next-line no-console

package/dist/src/commands/index.js

@@ -20,6 +20,16 @@ function registerAll(ctx, logger) {
         logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.deleteTool.name}`);
         ctx.registerTool(tools.lasDataProfilerTool);
         logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.lasDataProfilerTool.name}`);
+        ctx.registerTool(tools.listS3ObjectsTool);
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.listS3ObjectsTool.name}`);
+        ctx.registerTool(tools.readS3ObjectTool);
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.readS3ObjectTool.name}`);
+        ctx.registerTool(tools.writeLanceCatalogTool);
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.writeLanceCatalogTool.name}`);
+        ctx.registerTool(tools.readLanceCatalogTool);
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.readLanceCatalogTool.name}`);
+        ctx.registerTool(tools.generatePresignedUrlTool);
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.generatePresignedUrlTool.name}`);
         ctx.registerTool(tools.listDatasourceTool);
         logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.listDatasourceTool.name}`);
         for (const lasTool of tools.lasTools) {
@@ -40,15 +50,12 @@ function registerAll(ctx, logger) {
                 .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>')
+            contextlake.command('connect <datasource_name> <url>')
                 .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(commands.connectAction);
             // Ingest

package/dist/src/commands/slashcmd.js

@@ -133,18 +133,13 @@ function getSlashCommands(pluginConfig, logger) {
             const args = rawArgs.split(' ').filter((arg) => arg.trim() !== '');
             logger.info(`[${new Date().toISOString()}] [ContextLake] Slash command profiler started`, { args });
             try {
-                if (args.length < 4) {
-                    return { text: `**Error:** Missing arguments. Usage: /contextlake-profiler <datasource_name> <vendor> <bucket> <prefix> [endpoint] [ak] [sk] [region]` };
-                }
-                const [datasource_name, vendor, bucket, prefix, endpoint, access_key, secret_key, region] = args;
-                if (!['volcengine', 'alibaba', 'tencent', 'aws', 'local'].includes(vendor)) {
-                    return { text: `**Error:** Invalid vendor. Must be one of: volcengine, alibaba, tencent, aws, local` };
+                if (args.length < 2) {
+                    return { text: `**Error:** Missing arguments. Usage: /contextlake-profiler <datasource_name> <url> [endpoint] [ak] [sk] [region]` };
                 }
+                const [datasource_name, url, endpoint, access_key, secret_key, region] = args;
                 const params = {
                     datasource_name,
-                    vendor: vendor,
-                    bucket,
-                    prefix,
+                    url,
                     endpoint,
                     access_key,
                     secret_key,

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

@@ -7,5 +7,10 @@ export declare function getAgentTools(pluginConfig: ContextLakeConfig, logger: a
     deleteTool: AnyAgentTool;
     lasDataProfilerTool: AnyAgentTool;
     listDatasourceTool: AnyAgentTool;
+    listS3ObjectsTool: AnyAgentTool;
+    readS3ObjectTool: AnyAgentTool;
+    generatePresignedUrlTool: AnyAgentTool;
+    writeLanceCatalogTool: AnyAgentTool;
+    readLanceCatalogTool: AnyAgentTool;
     lasTools: AnyAgentTool[];
 };

package/dist/src/commands/tools.js

@@ -6,6 +6,8 @@ const retrieve_1 = require("../lib/actions/retrieve");
 const manage_1 = require("../lib/actions/manage");
 const profiler_1 = require("../lib/actions/profiler");
 const las_tools_1 = require("../lib/actions/las-tools");
+const s3_tools_1 = require("../lib/actions/s3-tools");
+const lance_tools_1 = require("../lib/actions/lance-tools");
 function getAgentTools(pluginConfig, logger) {
     const lasTools = (0, las_tools_1.getLasTools)(pluginConfig, logger);
     return {
@@ -251,16 +253,10 @@ Example User Queries:
                 type: 'object',
                 properties: {
                     datasource_name: { type: 'string', description: 'Name of the data source' },
-                    vendor: { type: 'string', enum: ['volcengine', 'alibaba', 'tencent', 'aws', 'local'], description: 'Data source type' },
-                    endpoint: { type: 'string', description: 'S3 Endpoint URL (not needed for local)' },
-                    access_key: { type: 'string', description: 'Credential ID for the data source' },
-                    secret_key: { type: 'string', description: 'Credential value for the data source' },
-                    region: { type: 'string', description: 'Region identifier (e.g. cn-beijing)' },
-                    bucket: { type: 'string', description: 'Bucket name (or local root directory for local vendor)' },
-                    prefix: { type: 'string', description: 'Path prefix to limit scan scope' },
+                    url: { type: 'string', description: 'Data source URL (e.g. tos://bucket/prefix, oss://..., s3://..., file:///path)' },
                     sample_rows: { type: 'integer', description: 'Number of rows to sample per structured file' }
                 },
-                required: ['datasource_name', 'vendor', 'bucket', 'prefix'],
+                required: ['datasource_name', 'url'],
                 additionalProperties: false
             },
             async execute(toolCallId, params) {
@@ -281,11 +277,185 @@ Example User Queries:
                     logger.error(`[${new Date().toISOString()}] [ContextLake] las-data-profiler skill failed`, { error: error.message, stack: error.stack });
                     return {
                         content: [{ type: "text", text: String(error.message) }],
-                        details: { error: error.message
-                        }
+                        details: { error: error.message }
                     };
                 }
             }
+        },
+        listS3ObjectsTool: {
+            name: 'list-s3-objects',
+            label: 'List S3 Objects',
+            description: 'List objects in an S3-compatible bucket or local directory',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'Data source URL (e.g. tos://bucket/prefix, oss://..., file:///path)' },
+                    vendor: { type: 'string', enum: ['volcengine', 'alibaba', 'tencent', 'aws', 'local'], description: 'Required if url is not provided' },
+                    bucket: { type: 'string', description: 'Required if url is not provided' },
+                    prefix: { type: 'string' },
+                    endpoint: { type: 'string' },
+                    maxKeys: { type: 'integer' },
+                    continuationToken: { type: 'string' }
+                },
+                required: [],
+                additionalProperties: false
+            },
+            async execute(toolCallId, params) {
+                let actualParams = params.params || params;
+                try {
+                    const result = await (0, s3_tools_1.listS3Objects)(actualParams, actualParams.prefix || '', actualParams.maxKeys, actualParams.continuationToken);
+                    return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
+                }
+                catch (e) {
+                    return { content: [{ type: "text", text: String(e.message) }], details: { error: e.message } };
+                }
+            }
+        },
+        readS3ObjectTool: {
+            name: 'read-s3-object',
+            label: 'Read S3 Object',
+            description: 'Read the contents or headers of an S3 object',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'Full URL to the object (e.g. tos://bucket/path/to/key.txt)' },
+                    vendor: { type: 'string', enum: ['volcengine', 'alibaba', 'tencent', 'aws', 'local'], description: 'Required if url is not provided' },
+                    bucket: { type: 'string', description: 'Required if url is not provided' },
+                    key: { type: 'string', description: 'Required if url is not provided' },
+                    endpoint: { type: 'string' },
+                    maxBytes: { type: 'integer' }
+                },
+                required: [],
+                additionalProperties: false
+            },
+            async execute(toolCallId, params) {
+                let actualParams = params.params || params;
+                try {
+                    // Extract key from url if provided
+                    let key = actualParams.key;
+                    if (actualParams.url && !key) {
+                        try {
+                            if (actualParams.url.startsWith('file://')) {
+                                // Key is not strictly needed for file://, bucket contains the path in parseS3Url
+                                key = '';
+                            }
+                            else {
+                                const parsedUrl = new URL(actualParams.url);
+                                key = parsedUrl.pathname.replace(/^\//, '');
+                            }
+                        }
+                        catch (e) {
+                            // let it fail in readS3Object
+                        }
+                    }
+                    if (!key && !actualParams.url?.startsWith('file://')) {
+                        throw new Error('key is required or must be part of the url');
+                    }
+                    const buf = await (0, s3_tools_1.readS3Object)(actualParams, key, actualParams.maxBytes);
+                    // Return as base64 string
+                    return { content: [{ type: "text", text: buf.toString('base64') }], details: { length: buf.length } };
+                }
+                catch (e) {
+                    return { content: [{ type: "text", text: String(e.message) }], details: { error: e.message } };
+                }
+            }
+        },
+        generatePresignedUrlTool: {
+            name: 'generate-presigned-url',
+            label: 'Generate Presigned URL',
+            description: 'Generate a presigned HTTP URL for an S3/TOS object, allowing temporary public access',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'Full URL to the object (e.g. tos://bucket/path/to/key.txt)' },
+                    vendor: { type: 'string', enum: ['volcengine', 'alibaba', 'tencent', 'aws', 'local'], description: 'Required if url is not provided' },
+                    bucket: { type: 'string', description: 'Required if url is not provided' },
+                    key: { type: 'string', description: 'Required if url is not provided' },
+                    endpoint: { type: 'string' },
+                    expiresIn: { type: 'integer', description: 'Expiration time in seconds (default 3600)' }
+                },
+                required: [],
+                additionalProperties: false
+            },
+            async execute(toolCallId, params) {
+                let actualParams = params.params || params;
+                try {
+                    let key = actualParams.key;
+                    if (actualParams.url && !key) {
+                        try {
+                            if (actualParams.url.startsWith('file://')) {
+                                key = '';
+                            }
+                            else {
+                                const parsedUrl = new URL(actualParams.url);
+                                key = parsedUrl.pathname.replace(/^\//, '');
+                            }
+                        }
+                        catch (e) {
+                            // let it fail in getPresignedUrl
+                        }
+                    }
+                    if (!key && !actualParams.url?.startsWith('file://')) {
+                        throw new Error('key is required or must be part of the url');
+                    }
+                    const url = await (0, s3_tools_1.getPresignedUrl)(actualParams, key, actualParams.expiresIn);
+                    return { content: [{ type: "text", text: url }], details: { url } };
+                }
+                catch (e) {
+                    return { content: [{ type: "text", text: String(e.message) }], details: { error: e.message } };
+                }
+            }
+        },
+        writeLanceCatalogTool: {
+            name: 'write-lance-catalog',
+            label: 'Write LanceDB Catalog',
+            description: 'Write an array of file records into a local LanceDB table',
+            parameters: {
+                type: 'object',
+                properties: {
+                    db_path: { type: 'string' },
+                    table_name: { type: 'string' },
+                    records: { type: 'array', items: { type: 'object' } }
+                },
+                required: ['db_path', 'table_name', 'records'],
+                additionalProperties: false
+            },
+            async execute(toolCallId, params) {
+                let actualParams = params.params || params;
+                try {
+                    await (0, lance_tools_1.writeLanceCatalog)(actualParams);
+                    return { content: [{ type: "text", text: "Successfully wrote records to LanceDB" }], details: { count: actualParams.records.length } };
+                }
+                catch (e) {
+                    return { content: [{ type: "text", text: String(e.message) }], details: { error: e.message } };
+                }
+            }
+        },
+        readLanceCatalogTool: {
+            name: 'read-lance-catalog',
+            label: 'Read LanceDB Catalog',
+            description: 'Read records from a local LanceDB table for validation or ingestion processes',
+            parameters: {
+                type: 'object',
+                properties: {
+                    db_path: { type: 'string', description: 'Path to the local LanceDB database' },
+                    table_name: { type: 'string', description: 'Name of the table to read' },
+                    limit: { type: 'integer', description: 'Maximum number of records to return' },
+                    filter: { type: 'string', description: 'SQL-like filter string (e.g., "category = \'structured\'")' }
+                },
+                required: ['db_path', 'table_name'],
+                additionalProperties: false
+            },
+            async execute(toolCallId, params) {
+                let actualParams = params.params || params;
+                try {
+                    const results = await (0, lance_tools_1.readLanceCatalog)(actualParams);
+                    return { content: [{ type: "text", text: JSON.stringify(results) }], details: { count: results.length, data: results } };
+                }
+                catch (e) {
+                    return { content: [{ type: "text", text: String(e.message) }], details: { error: e.message } };
+                }
+            }
         }
     };
 }

package/dist/src/lib/actions/lance-tools.d.ts

@@ -0,0 +1,13 @@
+export interface LanceWriteParams {
+    db_path: string;
+    table_name: string;
+    records: any[];
+}
+export interface LanceReadParams {
+    db_path: string;
+    table_name: string;
+    limit?: number;
+    filter?: string;
+}
+export declare function writeLanceCatalog(params: LanceWriteParams): Promise<void>;
+export declare function readLanceCatalog(params: LanceReadParams): Promise<any[]>;

package/dist/src/lib/actions/lance-tools.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeLanceCatalog = writeLanceCatalog;
+exports.readLanceCatalog = readLanceCatalog;
+const lancedb = __importStar(require("@lancedb/lancedb"));
+const fs = __importStar(require("fs"));
+async function writeLanceCatalog(params) {
+    if (!params.records || params.records.length === 0) {
+        return;
+    }
+    const db = await lancedb.connect(params.db_path);
+    const tableNames = await db.tableNames();
+    if (tableNames.includes(params.table_name)) {
+        const table = await db.openTable(params.table_name);
+        await table.add(params.records);
+    }
+    else {
+        await db.createTable(params.table_name, params.records);
+    }
+}
+async function readLanceCatalog(params) {
+    if (!fs.existsSync(params.db_path)) {
+        throw new Error(`Database not found at ${params.db_path}`);
+    }
+    const db = await lancedb.connect(params.db_path);
+    const tableNames = await db.tableNames();
+    if (!tableNames.includes(params.table_name)) {
+        throw new Error(`Table '${params.table_name}' not found in database`);
+    }
+    const table = await db.openTable(params.table_name);
+    let query = table.query();
+    if (params.filter) {
+        query = query.where(params.filter);
+    }
+    if (params.limit && params.limit > 0) {
+        query = query.limit(params.limit);
+    }
+    const results = await query.toArray();
+    return results;
+}