@siduri-x/knowledge 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+import { KnowledgeItem, KnowledgeOrgan } from '@siduri-x/core';
+export interface EKnowledgeConfig {
+    provider?: 'e-knowledge' | 'e-remote' | 'e-hub';
+    packPath?: string;
+    baseUrl?: string;
+    registryUrl?: string;
+    packId?: string;
+    timeoutMs?: number;
+    maxResponseBytes?: number;
+    preferredMode?: 'lexical' | 'semantic' | 'hybrid';
+}
+/**
+ * Validates whether an IP address belongs to loopback, private, link-local, or cloud metadata ranges.
+ */
+export declare function isBlockedIp(ip: string): boolean;
+export interface SafeUrlValidationOptions {
+    dnsLookup?: (hostname: string) => Promise<string[]>;
+}
+/**
+ * Validates a destination URL against SSRF rules:
+ * - Scheme must be http: or https:
+ * - Host must not resolve to blocked IP addresses
+ */
+export declare function validateSafeUrl(urlStr: string, options?: SafeUrlValidationOptions): Promise<URL>;
+/**
+ * Safe fetch wrapper that enforces:
+ * 1. Target URL validation (SSRF defense)
+ * 2. Manual redirect following with re-validation of each redirect target
+ * 3. Timeout via AbortController
+ * 4. Maximum response size limit
+ */
+export declare function safeFetch(urlStr: string, options?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    timeoutMs?: number;
+    maxBytes?: number;
+    maxRedirects?: number;
+}): Promise<Response>;
+export declare class EKnowledgeAdapter implements KnowledgeOrgan {
+    private loaded;
+    private readonly preferredMode;
+    constructor(config: EKnowledgeConfig);
+    get currentRevision(): Promise<string>;
+    search(query: string): Promise<KnowledgeItem[]>;
+}

package/dist/index.js

@@ -0,0 +1,299 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EKnowledgeAdapter = void 0;
+exports.isBlockedIp = isBlockedIp;
+exports.validateSafeUrl = validateSafeUrl;
+exports.safeFetch = safeFetch;
+const node_net_1 = __importDefault(require("node:net"));
+const promises_1 = __importDefault(require("node:dns/promises"));
+const loadEKnowledgeModule = () => new Function('specifier', 'return import(specifier)')('@vxnus/e-knowledge');
+const DEFAULT_MAX_RESPONSE_BYTES = 1024 * 1024; // 1MB
+/**
+ * Validates whether an IP address belongs to loopback, private, link-local, or cloud metadata ranges.
+ */
+function isBlockedIp(ip) {
+    // IPv4 checks
+    if (node_net_1.default.isIPv4(ip)) {
+        const parts = ip.split('.').map(Number);
+        if (parts.length !== 4 || parts.some(p => isNaN(p) || p < 0 || p > 255))
+            return true;
+        // 0.0.0.0/8 (Current network)
+        if (parts[0] === 0)
+            return true;
+        // 127.0.0.0/8 (Loopback)
+        if (parts[0] === 127)
+            return true;
+        // 10.0.0.0/8 (Private RFC1918)
+        if (parts[0] === 10)
+            return true;
+        // 172.16.0.0/12 (Private RFC1918)
+        if (parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31)
+            return true;
+        // 192.168.0.0/16 (Private RFC1918)
+        if (parts[0] === 192 && parts[1] === 168)
+            return true;
+        // 169.254.0.0/16 (Link-local / Cloud metadata)
+        if (parts[0] === 169 && parts[1] === 254)
+            return true;
+        // 100.64.0.0/10 (Carrier-grade NAT)
+        if (parts[0] === 100 && parts[1] >= 64 && parts[1] <= 127)
+            return true;
+        // 192.0.2.0/24, 198.51.100.0/24, 203.0.113.0/24 (TEST-NET)
+        if (parts[0] === 192 && parts[1] === 0 && parts[2] === 2)
+            return true;
+        if (parts[0] === 198 && parts[1] === 51 && parts[2] === 100)
+            return true;
+        if (parts[0] === 203 && parts[1] === 0 && parts[2] === 113)
+            return true;
+        // 224.0.0.0/4 (Multicast) & 240.0.0.0/4 (Reserved)
+        if (parts[0] >= 224)
+            return true;
+        return false;
+    }
+    // IPv6 checks
+    if (node_net_1.default.isIPv6(ip)) {
+        const normalized = ip.toLowerCase();
+        // ::1 (Loopback)
+        if (normalized === '::1' || normalized === '0:0:0:0:0:0:0:1')
+            return true;
+        // :: (Unspecified)
+        if (normalized === '::' || normalized === '0:0:0:0:0:0:0:0')
+            return true;
+        // IPv4-mapped IPv6 (::ffff:127.0.0.1)
+        if (normalized.startsWith('::ffff:')) {
+            const v4Part = normalized.slice(7);
+            if (node_net_1.default.isIPv4(v4Part))
+                return isBlockedIp(v4Part);
+        }
+        // fe80::/10 (Link-local)
+        if (normalized.startsWith('fe80:') || normalized.startsWith('fe8') || normalized.startsWith('fe9') || normalized.startsWith('fea') || normalized.startsWith('feb'))
+            return true;
+        // fc00::/7 (Unique local / ULA)
+        if (normalized.startsWith('fc') || normalized.startsWith('fd'))
+            return true;
+        return false;
+    }
+    // Non-IP string is invalid
+    return true;
+}
+/**
+ * Validates a destination URL against SSRF rules:
+ * - Scheme must be http: or https:
+ * - Host must not resolve to blocked IP addresses
+ */
+async function validateSafeUrl(urlStr, options = {}) {
+    let parsed;
+    try {
+        parsed = new URL(urlStr);
+    }
+    catch {
+        throw new Error(`Invalid URL provided: ${urlStr}`);
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        throw new Error(`Forbidden protocol: ${parsed.protocol}. Only http: and https: are allowed.`);
+    }
+    let hostname = parsed.hostname;
+    if (!hostname) {
+        throw new Error('URL hostname is required');
+    }
+    // Strip IPv6 brackets if present in hostname (e.g. "[::1]" -> "::1")
+    if (hostname.startsWith('[') && hostname.endsWith(']')) {
+        hostname = hostname.slice(1, -1);
+    }
+    // If hostname is already an IP address
+    if (node_net_1.default.isIP(hostname)) {
+        if (isBlockedIp(hostname)) {
+            throw new Error(`Blocked destination IP address: ${hostname}`);
+        }
+        return parsed;
+    }
+    // Resolve hostname via DNS
+    let addresses;
+    try {
+        if (options.dnsLookup) {
+            addresses = await options.dnsLookup(hostname);
+        }
+        else {
+            const res = await promises_1.default.lookup(hostname, { all: true });
+            addresses = res.map(r => r.address);
+        }
+    }
+    catch (err) {
+        throw new Error(`DNS resolution failed for hostname "${hostname}": ${err.message}`);
+    }
+    if (!addresses || addresses.length === 0) {
+        throw new Error(`No DNS records found for hostname: ${hostname}`);
+    }
+    for (const addr of addresses) {
+        if (isBlockedIp(addr)) {
+            throw new Error(`Hostname "${hostname}" resolved to blocked IP address: ${addr}`);
+        }
+    }
+    return parsed;
+}
+/**
+ * Safe fetch wrapper that enforces:
+ * 1. Target URL validation (SSRF defense)
+ * 2. Manual redirect following with re-validation of each redirect target
+ * 3. Timeout via AbortController
+ * 4. Maximum response size limit
+ */
+async function safeFetch(urlStr, options = {}) {
+    let currentUrl = urlStr;
+    const maxRedirects = options.maxRedirects ?? 3;
+    const timeoutMs = options.timeoutMs ?? 5000;
+    const maxBytes = options.maxBytes ?? DEFAULT_MAX_RESPONSE_BYTES;
+    for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount++) {
+        const validated = await validateSafeUrl(currentUrl);
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetch(validated.toString(), {
+                method: options.method || 'GET',
+                headers: options.headers,
+                body: options.body,
+                signal: controller.signal,
+                redirect: 'manual',
+            });
+            // Handle Redirects safely
+            if (response.status >= 300 && response.status < 400) {
+                const location = response.headers.get('location');
+                if (!location) {
+                    throw new Error(`HTTP ${response.status} redirect missing Location header`);
+                }
+                if (redirectCount >= maxRedirects) {
+                    throw new Error(`Exceeded maximum redirect limit of ${maxRedirects}`);
+                }
+                currentUrl = new URL(location, validated).toString();
+                continue;
+            }
+            // Check Content-Length header if present
+            const contentLengthHeader = response.headers.get('content-length');
+            if (contentLengthHeader) {
+                const contentLength = parseInt(contentLengthHeader, 10);
+                if (!isNaN(contentLength) && contentLength > maxBytes) {
+                    throw new Error(`Response size (${contentLength} bytes) exceeds limit of ${maxBytes} bytes`);
+                }
+            }
+            return response;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    throw new Error('Too many redirects');
+}
+async function safeFetchJson(urlStr, options = {}) {
+    const maxBytes = options.maxBytes ?? DEFAULT_MAX_RESPONSE_BYTES;
+    const response = await safeFetch(urlStr, options);
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    // Read response as text with size limit to prevent memory exhaustion
+    const text = await response.text();
+    if (text.length > maxBytes) {
+        throw new Error(`Response body length (${text.length} chars) exceeds maximum allowed ${maxBytes} bytes`);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (err) {
+        throw new Error(`Failed to parse JSON response: ${err.message}`);
+    }
+}
+async function resolveManifest(provider, baseUrl, timeoutMs, maxBytes) {
+    if (typeof provider.manifest === 'function') {
+        return await provider.manifest();
+    }
+    const cleanUrl = baseUrl.replace(/\/+$/, '');
+    return await safeFetchJson(`${cleanUrl}/manifest`, {
+        headers: { accept: 'application/json' },
+        timeoutMs: timeoutMs || 5000,
+        maxBytes,
+    });
+}
+async function resolveHubProvider(config, module) {
+    if (!config.registryUrl || !config.packId)
+        throw new Error('E Hub provider requires registryUrl and packId');
+    const match = config.packId.match(/^@([^/]+)\/([^/]+)$/);
+    if (!match)
+        throw new Error('E Hub packId must use the @publisher/name format');
+    const registryUrl = config.registryUrl.replace(/\/+$/, '');
+    const hubPackUrl = `${registryUrl}/${encodeURIComponent(match[1])}/${encodeURIComponent(match[2])}`;
+    const pack = await safeFetchJson(hubPackUrl, {
+        timeoutMs: config.timeoutMs,
+        maxBytes: config.maxResponseBytes,
+    });
+    if (pack.distribution?.kind !== 'provider' || !pack.distribution.url) {
+        throw new Error(`E Hub pack ${config.packId} is not a remote provider`);
+    }
+    const baseUrl = pack.distribution.url;
+    // Validate distribution URL against SSRF
+    await validateSafeUrl(baseUrl);
+    return {
+        provider: module.createRemoteProvider({ baseUrl, timeoutMs: config.timeoutMs, manifest: pack }),
+        baseUrl,
+        manifest: pack,
+    };
+}
+class EKnowledgeAdapter {
+    loaded;
+    preferredMode;
+    constructor(config) {
+        this.preferredMode = config.preferredMode ?? 'lexical';
+        this.loaded = loadEKnowledgeModule().then(async (module) => {
+            if (config.provider === 'e-hub') {
+                const { provider, baseUrl, manifest: hubManifest } = await resolveHubProvider(config, module);
+                let manifest;
+                try {
+                    manifest = await resolveManifest(provider, baseUrl, config.timeoutMs);
+                }
+                catch {
+                    if (!hubManifest)
+                        throw new Error('Could not resolve manifest for E Hub provider');
+                    manifest = hubManifest;
+                }
+                return { provider: provider, manifest };
+            }
+            if (config.provider === 'e-remote' || config.baseUrl) {
+                const baseUrl = config.baseUrl || '';
+                const provider = module.createRemoteProvider({ baseUrl, timeoutMs: config.timeoutMs });
+                const manifest = await resolveManifest(provider, baseUrl, config.timeoutMs);
+                return { provider: provider, manifest };
+            }
+            if (!config.packPath)
+                throw new Error('EKnowledgeAdapter requires packPath, baseUrl, or E Hub configuration');
+            return module.loadPack(config.packPath);
+        });
+    }
+    get currentRevision() { return this.loaded.then(pack => 'revision' in pack ? pack.revision.id : 'remote'); }
+    async search(query) {
+        const pack = await this.loaded;
+        if (!query.trim())
+            return [];
+        const requestedMode = this.preferredMode;
+        const manifest = pack.manifest;
+        const modeSupported = requestedMode === 'lexical' || manifest.capabilities.semanticSearch;
+        let response;
+        try {
+            response = await pack.provider.retrieve({ query, mode: modeSupported ? requestedMode : 'lexical', limit: 8 });
+        }
+        catch (error) {
+            if (requestedMode === 'lexical')
+                throw error;
+            // Semantic infrastructure is optional: an outage must not remove the
+            // provider's cited lexical path.
+            response = await pack.provider.retrieve({ query, mode: 'lexical', limit: 8 });
+        }
+        return response.results.map((result) => ({
+            content: result.content,
+            revision: result.revision,
+            citations: result.citations,
+            provenance: result.citations[0]?.sourceId || pack.manifest.publisher
+        }));
+    }
+}
+exports.EKnowledgeAdapter = EKnowledgeAdapter;

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.test.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = __importDefault(require("node:dns/promises"));
+const testPackPath = process.env.E_TEST_PACK_PATH || node_path_1.default.resolve(__dirname, '../../../../../e/packages/knowledge/fixtures/sample');
+describe('EKnowledgeAdapter', () => {
+    beforeEach(() => {
+        jest.spyOn(promises_1.default, 'lookup').mockImplementation(async (hostname) => {
+            if (hostname.includes('blocked') || hostname.includes('127.0.0.1')) {
+                return [{ address: '127.0.0.1', family: 4 }];
+            }
+            return [{ address: '93.184.216.34', family: 4 }]; // public IP
+        });
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    test('loads an E pack and preserves citations and revision', async () => {
+        const adapter = new index_1.EKnowledgeAdapter({ packPath: testPackPath });
+        const results = await adapter.search('grounded facts');
+        expect(results).toHaveLength(1);
+        expect(results[0]).toMatchObject({ content: 'Siduri knowledge packs provide grounded facts.', revision: 'r1' });
+        expect(results[0].citations[0]).toMatchObject({ sourceId: 'handbook', documentId: 'intro', chunkId: 'intro-1' });
+    });
+    test('does not retrieve for an empty query', async () => {
+        const adapter = new index_1.EKnowledgeAdapter({ packPath: testPackPath });
+        expect(await adapter.search('   ')).toEqual([]);
+    });
+    test('falls back to lexical when semantic capability is unavailable', async () => {
+        const fetchMock = jest.spyOn(globalThis, 'fetch').mockImplementation(async (input, init) => {
+            const url = String(input);
+            const data = url.endsWith('/manifest')
+                ? { id: '@publisher/installed-pack', name: 'installed-pack', publisher: 'publisher', version: '1.0.0', schemaVersion: '1.0', sources: [{ id: 'source', title: 'Source', license: 'CC-BY-4.0' }], capabilities: { lexicalSearch: true, semanticSearch: false, structuredEntities: true, relations: true, revisions: true } }
+                : { revision: 'r1', results: [{ id: 'c1', content: 'lexical fallback', revision: 'r1', citations: [{ sourceId: 'gi-data', chunkId: 'c1' }] }] };
+            if (!url.endsWith('/manifest')) {
+                expect(JSON.parse(String(init?.body)).mode).toBe('lexical');
+            }
+            return {
+                ok: true,
+                status: 200,
+                text: async () => JSON.stringify(data),
+                json: async () => data,
+                headers: new Headers(),
+            };
+        });
+        const adapter = new index_1.EKnowledgeAdapter({ provider: 'e-remote', baseUrl: 'https://provider.example/api/e', preferredMode: 'semantic' });
+        await expect(adapter.search('fallback')).resolves.toMatchObject([{ content: 'lexical fallback' }]);
+        fetchMock.mockRestore();
+    });
+    test('loads an E remote provider and preserves its citation contract', async () => {
+        const fetchMock = jest.spyOn(globalThis, 'fetch').mockImplementation(async (input) => {
+            const url = String(input);
+            const body = url.endsWith('/manifest')
+                ? { id: '@publisher/installed-pack', name: 'installed-pack', publisher: 'publisher', version: '1.0.0', schemaVersion: '1.0', sources: [{ id: 'source', title: 'Source', license: 'CC-BY-4.0' }], capabilities: { lexicalSearch: true, semanticSearch: false, structuredEntities: true, relations: true, revisions: true } }
+                : { revision: 'teyvat-r1', results: [{ id: 'chunk-1', content: 'Furina uses materials.', revision: 'teyvat-r1', citations: [{ sourceId: 'gi-data', documentId: 'doc-1', chunkId: 'chunk-1' }] }] };
+            return {
+                ok: true,
+                status: 200,
+                text: async () => JSON.stringify(body),
+                json: async () => body,
+                headers: new Headers(),
+            };
+        });
+        const adapter = new index_1.EKnowledgeAdapter({ provider: 'e-remote', baseUrl: 'https://provider.example/api/e' });
+        await expect(adapter.search('Furina')).resolves.toMatchObject([{ revision: 'teyvat-r1', provenance: 'gi-data' }]);
+        expect(fetchMock).toHaveBeenCalledWith(expect.stringContaining('/manifest'), expect.anything());
+        fetchMock.mockRestore();
+    });
+    test('resolves a provider distribution through the E Hub', async () => {
+        const fetchMock = jest.spyOn(globalThis, 'fetch').mockImplementation(async (input) => {
+            const url = String(input);
+            const body = url.includes('/api/packs/publisher/installed-pack')
+                ? { distribution: { kind: 'provider', url: 'https://provider.example/api/e' } }
+                : url.endsWith('/manifest')
+                    ? { id: '@publisher/installed-pack', name: 'installed-pack', publisher: 'publisher', version: '1.0.0', schemaVersion: '1.0', sources: [{ id: 'source', title: 'Source', license: 'CC-BY-4.0' }], capabilities: { lexicalSearch: true, semanticSearch: false, structuredEntities: true, relations: true, revisions: true } }
+                    : { revision: 'teyvat-r1', results: [{ id: 'chunk-1', content: 'hub fact', revision: 'teyvat-r1', citations: [{ sourceId: 'gi-data', documentId: 'doc-1', chunkId: 'chunk-1' }] }] };
+            return {
+                ok: true,
+                status: 200,
+                text: async () => JSON.stringify(body),
+                json: async () => body,
+                headers: new Headers(),
+            };
+        });
+        const adapter = new index_1.EKnowledgeAdapter({ provider: 'e-hub', registryUrl: 'https://hub.example/api/packs', packId: '@publisher/installed-pack' });
+        await expect(adapter.search('hub')).resolves.toMatchObject([{ content: 'hub fact', revision: 'teyvat-r1' }]);
+        expect(fetchMock).toHaveBeenCalledWith(expect.stringContaining('/api/packs/publisher/installed-pack'), expect.anything());
+        fetchMock.mockRestore();
+    });
+});
+describe('SSRF Hardening Suite', () => {
+    beforeEach(() => {
+        jest.spyOn(promises_1.default, 'lookup').mockImplementation(async (hostname) => {
+            if (hostname.includes('blocked') || hostname.includes('127.0.0.1') || hostname.includes('internal.corp')) {
+                return [{ address: '10.0.0.5', family: 4 }];
+            }
+            return [{ address: '93.184.216.34', family: 4 }]; // public IP
+        });
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    test('isBlockedIp identifies private, loopback, link-local, and cloud metadata IPs', () => {
+        expect((0, index_1.isBlockedIp)('127.0.0.1')).toBe(true);
+        expect((0, index_1.isBlockedIp)('127.255.255.255')).toBe(true);
+        expect((0, index_1.isBlockedIp)('10.0.0.1')).toBe(true);
+        expect((0, index_1.isBlockedIp)('172.16.0.1')).toBe(true);
+        expect((0, index_1.isBlockedIp)('192.168.1.1')).toBe(true);
+        expect((0, index_1.isBlockedIp)('169.254.169.254')).toBe(true); // AWS/GCP Metadata
+        expect((0, index_1.isBlockedIp)('0.0.0.0')).toBe(true);
+        expect((0, index_1.isBlockedIp)('::1')).toBe(true);
+        expect((0, index_1.isBlockedIp)('::ffff:127.0.0.1')).toBe(true);
+        expect((0, index_1.isBlockedIp)('fe80::1')).toBe(true);
+        expect((0, index_1.isBlockedIp)('fc00::1')).toBe(true);
+        // Public IPs should not be blocked
+        expect((0, index_1.isBlockedIp)('8.8.8.8')).toBe(false);
+        expect((0, index_1.isBlockedIp)('93.184.216.34')).toBe(false);
+        expect((0, index_1.isBlockedIp)('2606:2800:220:1:248:1893:25c8:1946')).toBe(false);
+    });
+    test('validateSafeUrl rejects non-http schemes and blocked IPs', async () => {
+        await expect((0, index_1.validateSafeUrl)('file:///etc/passwd')).rejects.toThrow(/Forbidden protocol/);
+        await expect((0, index_1.validateSafeUrl)('ftp://example.com')).rejects.toThrow(/Forbidden protocol/);
+        await expect((0, index_1.validateSafeUrl)('http://127.0.0.1:8080/manifest')).rejects.toThrow(/Blocked destination IP address/);
+        await expect((0, index_1.validateSafeUrl)('http://169.254.169.254/latest/meta-data')).rejects.toThrow(/Blocked destination IP address/);
+        await expect((0, index_1.validateSafeUrl)('http://0.0.0.0/')).rejects.toThrow(/Blocked destination IP address/);
+        await expect((0, index_1.validateSafeUrl)('http://100.64.0.1/')).rejects.toThrow(/Blocked destination IP address/); // CGNAT
+        await expect((0, index_1.validateSafeUrl)('http://[::1]/')).rejects.toThrow(/Blocked destination IP address/); // IPv6 loopback
+        await expect((0, index_1.validateSafeUrl)('http://[fc00::1]/')).rejects.toThrow(/Blocked destination IP address/); // IPv6 ULA
+    });
+    test('validateSafeUrl rejects hostnames resolving to private IPs', async () => {
+        jest.spyOn(promises_1.default, 'lookup').mockResolvedValueOnce([{ address: '10.0.0.5', family: 4 }]);
+        await expect((0, index_1.validateSafeUrl)('https://internal.corp/manifest')).rejects.toThrow(/resolved to blocked IP address/);
+    });
+    test('safeFetch rejects open redirects pointing to internal IP addresses', async () => {
+        const fetchMock = jest.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+            status: 302,
+            ok: false,
+            headers: new Headers({ location: 'http://169.254.169.254/latest/meta-data' }),
+            text: async () => '',
+        });
+        await expect((0, index_1.safeFetch)('https://public.example/redirect')).rejects.toThrow(/Blocked destination IP address/);
+        fetchMock.mockRestore();
+    });
+});

package/organ-manifest.json

@@ -0,0 +1,76 @@
+{
+  "name": "@siduri-x/knowledge",
+  "organType": "knowledge",
+  "version": "1.0.0",
+  "displayName": "Knowledge (E-Compatible Cited Facts)",
+  "description": "Factual context retrieval from local or hosted E Knowledge packs",
+  "entrypoint": "./dist/index.js",
+  "factory": "EKnowledgeAdapter",
+  "configKey": "knowledge",
+  "configSchema": {
+    "type": "object",
+    "required": [
+      "provider"
+    ],
+    "properties": {
+      "provider": {
+        "type": "string",
+        "enum": [
+          "e-knowledge",
+          "e-remote",
+          "e-hub",
+          "none"
+        ]
+      },
+      "packPath": {
+        "type": "string"
+      },
+      "baseUrl": {
+        "type": "string"
+      },
+      "registryUrl": {
+        "type": "string"
+      },
+      "packId": {
+        "type": "string"
+      },
+      "timeoutMs": {
+        "type": "number",
+        "default": 5000
+      },
+      "preferredMode": {
+        "type": "string",
+        "enum": [
+          "lexical",
+          "semantic",
+          "hybrid"
+        ],
+        "default": "lexical"
+      }
+    }
+  },
+  "environment": [
+    {
+      "name": "SIDURI_KNOWLEDGE_PACK",
+      "required": false,
+      "secret": false,
+      "description": "Path to local E knowledge pack"
+    },
+    {
+      "name": "SIDURI_KNOWLEDGE_REGISTRY_URL",
+      "required": false,
+      "secret": false,
+      "default": "https://e.vxnus.xyz/api/v1/knowledge",
+      "description": "URL of the E Knowledge Hub registry"
+    }
+  ],
+  "services": [
+    {
+      "name": "E Knowledge Hub",
+      "kind": "http_service",
+      "optional": true
+    }
+  ],
+  "database": null,
+  "healthCheck": null
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@siduri-x/knowledge",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --config jest.config.json"
+  },
+  "dependencies": {
+    "@vxnus/e": "^0.1.4",
+    "@vxnus/e-knowledge": "^0.1.4",
+    "@siduri-x/core": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^26.2.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.12",
+    "typescript": "^5.3.3"
+  },
+  "description": "Knowledge organ for semantic search and retrieval from external sources",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vxnuslabs/siduri-y",
+    "directory": "packages/organs/knowledge"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist",
+    "organ-manifest.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./organ-manifest.json": "./organ-manifest.json"
+  }
+}