@undefineds.co/xpod 0.3.75 → 0.4.0-rc.140

package/dist/storage/sparql/SimpleSparqlExecutor.d.ts

@@ -1,40 +0,0 @@
-/**
- * SimpleSparqlExecutor - 绕过 Comunica 执行简单 SPARQL UPDATE
- *
- * 针对 Pod 创建场景优化：
- * - 直接解析 INSERT DATA / DELETE DATA
- * - 不经过 Comunica 的复杂查询计划
- * - 批量执行，减少事务开销
- */
-import type { QuintStore } from '../quint/types';
-/**
- * 简单的 SPARQL UPDATE 解析器
- * 只处理 INSERT DATA / DELETE DATA 的简单形式
- */
-export declare class SimpleSparqlExecutor {
-    private readonly store;
-    constructor(store: QuintStore);
-    /**
-     * 尝试执行简单的 SPARQL UPDATE
-     * @returns true 如果成功执行，false 如果不支持该查询格式
-     */
-    tryExecute(query: string): Promise<boolean>;
-    /**
-     * 解析简单的 SPARQL UPDATE
-     * 支持的格式：
-     * - INSERT DATA { GRAPH <uri> { ... } }
-     * - DELETE DATA { GRAPH <uri> { ... } }
-     * - INSERT DATA { ... }
-     * - DELETE DATA { ... }
-     */
-    private parseSimpleUpdate;
-    /**
-     * 从代码块解析三元组
-     * 简单实现，只处理基本格式
-     */
-    private parseQuadsFromBlock;
-    /**
-     * 解析 Turtle 格式的三元组（简化版）
-     */
-    private parseTriples;
-}

package/dist/storage/sparql/SimpleSparqlExecutor.js

@@ -1,131 +0,0 @@
-"use strict";
-/**
- * SimpleSparqlExecutor - 绕过 Comunica 执行简单 SPARQL UPDATE
- *
- * 针对 Pod 创建场景优化：
- * - 直接解析 INSERT DATA / DELETE DATA
- * - 不经过 Comunica 的复杂查询计划
- * - 批量执行，减少事务开销
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleSparqlExecutor = void 0;
-/**
- * 简单的 SPARQL UPDATE 解析器
- * 只处理 INSERT DATA / DELETE DATA 的简单形式
- */
-class SimpleSparqlExecutor {
-    constructor(store) {
-        this.store = store;
-    }
-    /**
-     * 尝试执行简单的 SPARQL UPDATE
-     * @returns true 如果成功执行，false 如果不支持该查询格式
-     */
-    async tryExecute(query) {
-        const pattern = this.parseSimpleUpdate(query);
-        if (!pattern) {
-            return false; // 不支持，让调用方使用 Comunica
-        }
-        if (pattern.type === 'insert') {
-            await this.store.multiPut(pattern.quads);
-        }
-        else {
-            // 逐条删除（因为 QuintStore 没有 multiDel 方法）
-            for (const q of pattern.quads) {
-                await this.store.del({
-                    graph: q.graph,
-                    subject: q.subject,
-                    predicate: q.predicate,
-                    object: q.object,
-                });
-            }
-        }
-        return true;
-    }
-    /**
-     * 解析简单的 SPARQL UPDATE
-     * 支持的格式：
-     * - INSERT DATA { GRAPH <uri> { ... } }
-     * - DELETE DATA { GRAPH <uri> { ... } }
-     * - INSERT DATA { ... }
-     * - DELETE DATA { ... }
-     */
-    parseSimpleUpdate(query) {
-        const trimmed = query.trim();
-        // 检查是否是 INSERT DATA
-        const insertMatch = trimmed.match(/^INSERT\s+DATA\s*\{/i);
-        if (insertMatch) {
-            const quads = this.parseQuadsFromBlock(trimmed, 'INSERT DATA');
-            if (quads) {
-                return { type: 'insert', quads };
-            }
-        }
-        // 检查是否是 DELETE DATA
-        const deleteMatch = trimmed.match(/^DELETE\s+DATA\s*\{/i);
-        if (deleteMatch) {
-            const quads = this.parseQuadsFromBlock(trimmed, 'DELETE DATA');
-            if (quads) {
-                return { type: 'delete', quads };
-            }
-        }
-        return null; // 不支持
-    }
-    /**
-     * 从代码块解析三元组
-     * 简单实现，只处理基本格式
-     */
-    parseQuadsFromBlock(query, prefix) {
-        // 提取大括号内的内容
-        const blockStart = query.indexOf('{');
-        const blockEnd = query.lastIndexOf('}');
-        if (blockStart === -1 || blockEnd === -1 || blockEnd <= blockStart) {
-            return null;
-        }
-        let content = query.slice(blockStart + 1, blockEnd).trim();
-        // 检查是否有 GRAPH 块
-        const graphMatch = content.match(/GRAPH\s*<([^>]+)>\s*\{/);
-        if (graphMatch) {
-            const graphUri = graphMatch[1];
-            const graphBlockStart = content.indexOf('{', content.indexOf('GRAPH'));
-            const graphBlockEnd = content.indexOf('}', graphBlockStart);
-            if (graphBlockStart === -1 || graphBlockEnd === -1) {
-                return null;
-            }
-            content = content.slice(graphBlockStart + 1, graphBlockEnd).trim();
-            // 解析三元组并添加 graph
-            const triples = this.parseTriples(content);
-            if (!triples)
-                return null;
-            const { DataFactory } = require('n3');
-            const { namedNode } = DataFactory;
-            return triples.map(t => ({
-                ...t,
-                graph: namedNode(graphUri),
-            }));
-        }
-        // 没有 GRAPH，使用默认图
-        return this.parseTriples(content);
-    }
-    /**
-     * 解析 Turtle 格式的三元组（简化版）
-     */
-    parseTriples(content) {
-        // 简化实现：使用 N3 Parser
-        try {
-            const { Parser, DataFactory } = require('n3');
-            const { defaultGraph } = DataFactory;
-            const parser = new Parser();
-            const quads = parser.parse(content);
-            // 为没有 graph 的 quad 添加默认图
-            return quads.map((q) => ({
-                ...q,
-                graph: q.graph || defaultGraph(),
-            }));
-        }
-        catch (error) {
-            return null;
-        }
-    }
-}
-exports.SimpleSparqlExecutor = SimpleSparqlExecutor;
-//# sourceMappingURL=SimpleSparqlExecutor.js.map

package/dist/storage/vector/VectorIndexingListener.d.ts

@@ -1,114 +0,0 @@
-/**
- * VectorIndexingListener - 向量索引监听器
- *
- * 监听资源变更事件，自动触发向量索引更新。
- *
- * 工作流程：
- * 1. 收到资源变更事件
- * 2. 检查资源是否在某个 VectorStore 的 scope 内
- * 3. 如果是，读取资源内容，生成 embedding，存入向量库
- */
-import type { ResourceChangeEvent, ResourceChangeListener } from '../ObservableResourceStore';
-import type { VectorStore } from '../vector/VectorStore';
-import type { EmbeddingService } from '../../ai/service/EmbeddingService';
-import type { SparqlEngine } from '../sparql/SubgraphQueryEngine';
-import type { ResourceStore } from '@solid/community-server';
-/**
- * VectorStore 定义（从 RDF 读取）
- */
-export interface VectorStoreDefinition {
-    /** VectorStore resource */
-    resource: string;
-    /** 索引范围（Container resource） */
-    scope: string;
-    /** embedding 模型 */
-    model: string;
-    /** 状态 */
-    status: 'active' | 'paused';
-    /** 分块大小 */
-    chunkSize?: number;
-    /** 分块重叠 */
-    chunkOverlap?: number;
-}
-export interface VectorIndexingListenerOptions {
-    /** SPARQL 引擎（用于查询 VectorStore 定义和 AI 凭据） */
-    sparqlEngine: SparqlEngine;
-    /** 向量存储 */
-    vectorStore: VectorStore;
-    /** Embedding 服务 */
-    embeddingService: EmbeddingService;
-    /** 资源存储（用于读取资源内容） */
-    resourceStore: ResourceStore;
-    /** 默认 embedding 模型 */
-    defaultModel?: string;
-    /** 支持的文件扩展名 */
-    supportedExtensions?: string[];
-}
-/**
- * VectorIndexingListener - 自动向量索引
- */
-export declare class VectorIndexingListener implements ResourceChangeListener {
-    protected readonly logger: import("global-logger-factory").Logger<unknown>;
-    private readonly sparqlEngine;
-    private readonly vectorStore;
-    private readonly embeddingService;
-    private readonly resourceStore;
-    private readonly defaultModel;
-    private readonly supportedExtensions;
-    private vectorStoreCache;
-    private cacheExpiry;
-    private readonly cacheTtlMs;
-    constructor(options: VectorIndexingListenerOptions);
-    /**
-     * 处理资源变更事件
-     */
-    onResourceChanged(event: ResourceChangeEvent): Promise<void>;
-    /**
-     * 处理删除操作
-     */
-    private handleDelete;
-    /**
-     * 处理创建或更新操作
-     */
-    private handleCreateOrUpdate;
-    /**
-     * 查找覆盖指定路径的 VectorStore
-     */
-    private findVectorStoresForPath;
-    /**
-     * 获取 Pod 的所有 VectorStore 定义
-     */
-    private getVectorStoreDefinitions;
-    /**
-     * 获取 AI 凭据
-     */
-    private getAiCredential;
-    /**
-     * 读取资源内容
-     */
-    private getResourceContent;
-    /**
-     * 检查是否为支持的文件类型
-     */
-    private isSupportedFile;
-    /**
-     * 获取文件扩展名
-     */
-    private getExtension;
-    /**
-     * 从路径提取 Pod base URL
-     */
-    private getPodBaseUrl;
-    /**
-     * 解析相对资源引用
-     */
-    private resolveResource;
-    /**
-     * 将路径转换为向量 ID（使用 hash）
-     */
-    private pathToVectorId;
-    /**
-     * 清除缓存
-     */
-    clearCache(): void;
-}

package/dist/storage/vector/VectorIndexingListener.js

@@ -1,346 +0,0 @@
-"use strict";
-/**
- * VectorIndexingListener - 向量索引监听器
- *
- * 监听资源变更事件，自动触发向量索引更新。
- *
- * 工作流程：
- * 1. 收到资源变更事件
- * 2. 检查资源是否在某个 VectorStore 的 scope 内
- * 3. 如果是，读取资源内容，生成 embedding，存入向量库
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VectorIndexingListener = void 0;
-const global_logger_factory_1 = require("global-logger-factory");
-const models_1 = require("@undefineds.co/models");
-/**
- * VectorIndexingListener - 自动向量索引
- */
-class VectorIndexingListener {
-    constructor(options) {
-        this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
-        // 缓存 VectorStore 定义，避免频繁查询
-        this.vectorStoreCache = new Map();
-        this.cacheExpiry = 0;
-        this.cacheTtlMs = 60000; // 1 分钟缓存
-        this.sparqlEngine = options.sparqlEngine;
-        this.vectorStore = options.vectorStore;
-        this.embeddingService = options.embeddingService;
-        this.resourceStore = options.resourceStore;
-        this.defaultModel = options.defaultModel ?? 'text-embedding-004';
-        this.supportedExtensions = new Set(options.supportedExtensions ?? ['.txt', '.md', '.html', '.json', '.ttl', '.jsonld']);
-    }
-    /**
-     * 处理资源变更事件
-     */
-    async onResourceChanged(event) {
-        const { path, action, isContainer } = event;
-        // 跳过容器变更
-        if (isContainer) {
-            this.logger.debug(`Skipping container: ${path}`);
-            return;
-        }
-        // 检查文件扩展名
-        if (!this.isSupportedFile(path)) {
-            this.logger.debug(`Skipping unsupported file type: ${path}`);
-            return;
-        }
-        // 获取 Pod base URL
-        const podBaseUrl = this.getPodBaseUrl(path);
-        if (!podBaseUrl) {
-            this.logger.debug(`Cannot determine pod base URL for: ${path}`);
-            return;
-        }
-        // 如果是 VectorStore 配置文件或 Credential 配置文件更新，清除缓存
-        if (path.includes('vector-stores') || path.includes('credentials')) {
-            this.logger.debug(`Configuration file updated, clearing cache for ${podBaseUrl}`);
-            this.vectorStoreCache.delete(podBaseUrl);
-            // 配置文件本身不需要索引，直接返回
-            return;
-        }
-        try {
-            // 查找覆盖此路径的 VectorStore
-            const vectorStores = await this.findVectorStoresForPath(path, podBaseUrl);
-            if (vectorStores.length === 0) {
-                this.logger.debug(`No VectorStore configured for: ${path}`);
-                return;
-            }
-            this.logger.info(`Processing ${action} for ${path}, matched ${vectorStores.length} VectorStore(s)`);
-            // 根据 action 执行索引操作
-            if (action === 'delete') {
-                await this.handleDelete(path, vectorStores);
-            }
-            else {
-                await this.handleCreateOrUpdate(path, podBaseUrl, vectorStores);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Failed to process ${action} for ${path}: ${error}`);
-        }
-    }
-    /**
-     * 处理删除操作
-     */
-    async handleDelete(path, vectorStores) {
-        const vectorId = this.pathToVectorId(path);
-        for (const vs of vectorStores) {
-            try {
-                await this.vectorStore.deleteVector(vs.model, vectorId);
-                this.logger.info(`Deleted vector for ${path} from model ${vs.model}`);
-            }
-            catch (error) {
-                this.logger.error(`Failed to delete vector for ${path}: ${error}`);
-            }
-        }
-    }
-    /**
-     * 处理创建或更新操作
-     */
-    async handleCreateOrUpdate(path, podBaseUrl, vectorStores) {
-        // 读取资源内容
-        const content = await this.getResourceContent(path);
-        if (!content || content.trim().length === 0) {
-            this.logger.debug(`Empty content for ${path}, skipping`);
-            return;
-        }
-        // 获取 AI 凭据
-        const credential = await this.getAiCredential(podBaseUrl);
-        if (!credential) {
-            this.logger.warn(`No AI credential found for ${podBaseUrl}, skipping indexing`);
-            return;
-        }
-        // 为每个 VectorStore 生成 embedding 并存储
-        // 注意：如果多个 VectorStore 使用相同的 model，只需要生成一次 embedding
-        const modelEmbeddings = new Map();
-        for (const vs of vectorStores) {
-            if (vs.status !== 'active') {
-                this.logger.debug(`VectorStore ${vs.resource} is ${vs.status}, skipping`);
-                continue;
-            }
-            const model = vs.model || this.defaultModel;
-            try {
-                // 检查是否已经生成过这个 model 的 embedding
-                let embedding = modelEmbeddings.get(model);
-                if (!embedding) {
-                    embedding = await this.embeddingService.embed(content, credential, model);
-                    modelEmbeddings.set(model, embedding);
-                }
-                // 确保向量表存在
-                await this.vectorStore.ensureVectorTable(model);
-                // 存储向量
-                const vectorId = this.pathToVectorId(path);
-                await this.vectorStore.upsertVector(model, vectorId, embedding);
-                this.logger.info(`Indexed ${path} to model ${model}, vectorId=${vectorId}`);
-            }
-            catch (error) {
-                this.logger.error(`Failed to index ${path} to model ${model}: ${error}`);
-            }
-        }
-    }
-    /**
-     * 查找覆盖指定路径的 VectorStore
-     */
-    async findVectorStoresForPath(path, podBaseUrl) {
-        const allStores = await this.getVectorStoreDefinitions(podBaseUrl);
-        return allStores.filter((vs) => {
-            // 检查 path 是否在 scope 内
-            const scope = vs.scope.endsWith('/') ? vs.scope : `${vs.scope}/`;
-            return path.startsWith(scope);
-        });
-    }
-    /**
-     * 获取 Pod 的所有 VectorStore 定义
-     */
-    async getVectorStoreDefinitions(podBaseUrl) {
-        // 检查缓存
-        if (Date.now() < this.cacheExpiry && this.vectorStoreCache.has(podBaseUrl)) {
-            return this.vectorStoreCache.get(podBaseUrl);
-        }
-        try {
-            // 使用 undefineds.co/ns# 命名空间，与 drizzle-solid schema 一致
-            const query = `
-        PREFIX udfs: <https://undefineds.co/ns#>
-        SELECT ?vs ?scope ?model ?status ?chunkSize ?chunkOverlap WHERE {
-          ?vs a udfs:VectorStore ;
-              udfs:container ?scope .
-          OPTIONAL { ?vs udfs:chunkingStrategy ?model }
-          OPTIONAL { ?vs udfs:status ?status }
-          OPTIONAL { ?vs udfs:chunkSize ?chunkSize }
-          OPTIONAL { ?vs udfs:chunkOverlap ?chunkOverlap }
-        }
-      `;
-            const bindingsStream = await this.sparqlEngine.queryBindings(query, podBaseUrl);
-            const definitions = [];
-            for await (const binding of bindingsStream) {
-                const vs = binding.get('vs');
-                const scope = binding.get('scope');
-                const model = binding.get('model');
-                const status = binding.get('status');
-                const chunkSize = binding.get('chunkSize');
-                const chunkOverlap = binding.get('chunkOverlap');
-                if (vs && scope) {
-                    definitions.push({
-                        resource: vs.value,
-                        scope: this.resolveResource(scope.value, podBaseUrl),
-                        model: model?.value || this.defaultModel,
-                        status: status?.value || 'active',
-                        chunkSize: chunkSize ? parseInt(chunkSize.value, 10) : undefined,
-                        chunkOverlap: chunkOverlap ? parseInt(chunkOverlap.value, 10) : undefined,
-                    });
-                }
-            }
-            // 更新缓存
-            this.vectorStoreCache.set(podBaseUrl, definitions);
-            this.cacheExpiry = Date.now() + this.cacheTtlMs;
-            this.logger.debug(`Found ${definitions.length} VectorStore(s) for ${podBaseUrl}`);
-            return definitions;
-        }
-        catch (error) {
-            this.logger.error(`Failed to query VectorStore definitions: ${error}`);
-            return [];
-        }
-    }
-    /**
-     * 获取 AI 凭据
-     */
-    async getAiCredential(podBaseUrl) {
-        try {
-            // Credential -> Provider 关联，从 Provider 获取 baseUrl 和 proxyUrl
-            const query = `
-        PREFIX cred: <${models_1.UDFS.NAMESPACE}>
-        PREFIX ai: <${models_1.UDFS.NAMESPACE}>
-        SELECT ?apiKey ?baseUrl ?provider ?proxyUrl WHERE {
-          ?cred a cred:Credential ;
-                cred:service "ai" ;
-                cred:status "active" ;
-                cred:apiKey ?apiKey .
-          OPTIONAL { ?cred cred:provider ?provider }
-          OPTIONAL { 
-            ?cred cred:provider ?provider .
-            ?provider ai:baseUrl ?baseUrl .
-          }
-          OPTIONAL { 
-            ?cred cred:provider ?provider .
-            ?provider ai:proxyUrl ?proxyUrl .
-          }
-        } LIMIT 1
-      `;
-            const bindingsStream = await this.sparqlEngine.queryBindings(query, podBaseUrl);
-            for await (const binding of bindingsStream) {
-                const apiKey = binding.get('apiKey');
-                const baseUrl = binding.get('baseUrl');
-                const provider = binding.get('provider');
-                const proxyUrl = binding.get('proxyUrl');
-                if (apiKey) {
-                    const providerName = (0, models_1.normalizeAIConfigProviderId)(provider?.value || 'google') || 'google';
-                    return {
-                        apiKey: apiKey.value,
-                        baseUrl: baseUrl?.value,
-                        provider: providerName,
-                        proxyUrl: proxyUrl?.value,
-                    };
-                }
-            }
-            return null;
-        }
-        catch (error) {
-            this.logger.error(`Failed to query AI credential: ${error}`);
-            return null;
-        }
-    }
-    /**
-     * 读取资源内容
-     */
-    async getResourceContent(path) {
-        try {
-            const preferences = {
-                type: { 'text/plain': 1, 'text/markdown': 0.9, 'text/turtle': 0.8, '*/*': 0.1 },
-            };
-            const representation = await this.resourceStore.getRepresentation({ path }, preferences);
-            const chunks = [];
-            for await (const chunk of representation.data) {
-                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-            }
-            return Buffer.concat(chunks).toString('utf-8');
-        }
-        catch (error) {
-            this.logger.error(`Failed to read resource ${path}: ${error}`);
-            return null;
-        }
-    }
-    /**
-     * 检查是否为支持的文件类型
-     */
-    isSupportedFile(path) {
-        const ext = this.getExtension(path);
-        return this.supportedExtensions.has(ext);
-    }
-    /**
-     * 获取文件扩展名
-     */
-    getExtension(path) {
-        const lastDot = path.lastIndexOf('.');
-        if (lastDot === -1)
-            return '';
-        return path.slice(lastDot).toLowerCase();
-    }
-    /**
-     * 从路径提取 Pod base URL
-     */
-    getPodBaseUrl(path) {
-        // 假设路径格式为 /username/... 或 https://pod.example.com/username/...
-        try {
-            const url = new URL(path, 'http://localhost');
-            const parts = url.pathname.split('/').filter(Boolean);
-            if (parts.length > 0) {
-                return `${url.origin}/${parts[0]}/`;
-            }
-        }
-        catch {
-            // 相对路径
-            const parts = path.split('/').filter(Boolean);
-            if (parts.length > 0) {
-                return `/${parts[0]}/`;
-            }
-        }
-        return null;
-    }
-    /**
-     * 解析相对资源引用
-     */
-    resolveResource(resource, baseUrl) {
-        if (resource.startsWith('http://') || resource.startsWith('https://')) {
-            return resource;
-        }
-        if (resource.startsWith('/')) {
-            try {
-                const base = new URL(baseUrl);
-                return `${base.origin}${resource}`;
-            }
-            catch {
-                return resource;
-            }
-        }
-        return `${baseUrl}${resource}`;
-    }
-    /**
-     * 将路径转换为向量 ID（使用 hash）
-     */
-    pathToVectorId(path) {
-        let hash = 2166136261; // FNV offset basis
-        for (let i = 0; i < path.length; i++) {
-            hash ^= path.charCodeAt(i);
-            hash = Math.imul(hash, 16777619); // FNV prime
-        }
-        return Math.abs(hash);
-    }
-    /**
-     * 清除缓存
-     */
-    clearCache() {
-        this.vectorStoreCache.clear();
-        this.cacheExpiry = 0;
-    }
-}
-exports.VectorIndexingListener = VectorIndexingListener;
-//# sourceMappingURL=VectorIndexingListener.js.map