stellavault 0.1.0 → 0.2.1

package/packages/core/dist/capture/voice.js

@@ -0,0 +1,135 @@
+// Voice Knowledge Capture (P3-F25)
+// 음성 파일 → 텍스트 → 자동 분류 → vault 저장 → 인덱싱
+import { execFileSync, execSync } from 'node:child_process';
+import { writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join, basename } from 'node:path';
+// CRIT-03: 화이트리스트 검증
+const ALLOWED_MODELS = ['tiny', 'base', 'small', 'medium', 'large'];
+const ALLOWED_LANGUAGES = ['auto', 'en', 'ko', 'ja', 'zh', 'es', 'fr', 'de', 'it', 'pt', 'ru', 'ar', 'hi'];
+function validateModel(model) {
+    if (!ALLOWED_MODELS.includes(model))
+        throw new Error(`Invalid model: ${model}. Allowed: ${ALLOWED_MODELS.join(', ')}`);
+    return model;
+}
+function validateLanguage(lang) {
+    if (!ALLOWED_LANGUAGES.includes(lang))
+        throw new Error(`Invalid language: ${lang}. Allowed: ${ALLOWED_LANGUAGES.join(', ')}`);
+    return lang;
+}
+// Whisper CLI가 설치되어 있는지 확인
+export function isWhisperAvailable() {
+    try {
+        execSync('whisper --help', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// 음성 파일 → 텍스트 변환 (Whisper CLI)
+export async function transcribeAudio(audioPath, options = {}) {
+    const { model = 'base', language } = options;
+    if (!existsSync(audioPath)) {
+        throw new Error(`Audio file not found: ${audioPath}`);
+    }
+    // CRIT-03 fix: execFileSync + 화이트리스트 검증 (command injection 방지)
+    if (isWhisperAvailable()) {
+        const safeModel = validateModel(model);
+        const args = [audioPath, '--model', safeModel, '--output_format', 'txt', '--output_dir', '/tmp/sv-whisper'];
+        if (language)
+            args.push('--language', validateLanguage(language));
+        mkdirSync('/tmp/sv-whisper', { recursive: true });
+        try {
+            execFileSync('whisper', args, { stdio: 'pipe', timeout: 300000 });
+            const outputName = basename(audioPath).replace(/\.[^.]+$/, '.txt');
+            const { readFileSync } = await import('node:fs');
+            return readFileSync(join('/tmp/sv-whisper', outputName), 'utf-8').trim();
+        }
+        catch (err) {
+            throw new Error(`Whisper failed: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    // Whisper 없으면 에러
+    throw new Error('Whisper not installed. Install: pip install openai-whisper');
+}
+// 트랜스크립트에서 자동 태그 추출 (간단한 키워드 매칭)
+function autoTag(text) {
+    const tags = [];
+    const lower = text.toLowerCase();
+    const keywords = {
+        'meeting': ['meeting', 'discuss', '미팅', '회의'],
+        'decision': ['decide', 'agreed', '결정', '합의'],
+        'idea': ['idea', 'thought', '아이디어', '생각'],
+        'todo': ['todo', 'task', 'action item', '할 일'],
+        'bug': ['bug', 'error', 'fix', '버그', '에러'],
+        'architecture': ['architecture', 'design', 'system', '아키텍처', '설계'],
+    };
+    for (const [tag, words] of Object.entries(keywords)) {
+        if (words.some(w => lower.includes(w)))
+            tags.push(tag);
+    }
+    return tags;
+}
+// 음성 → vault 노트 생성
+export async function captureVoice(audioPath, options) {
+    const { vaultPath, folder = '01_Knowledge/voice', type = 'note', tags: userTags = [] } = options;
+    try {
+        // 1. 음성→텍스트
+        const transcript = await transcribeAudio(audioPath, {
+            model: options.model,
+            language: options.language,
+        });
+        if (!transcript) {
+            return { title: '', filePath: '', transcript: '', tags: [], success: false, error: 'Empty transcript' };
+        }
+        // 2. 제목 생성 (첫 문장 또는 첫 30자)
+        const firstLine = transcript.split(/[.\n!?]/)[0]?.trim() || transcript.slice(0, 30);
+        const title = firstLine.slice(0, 60);
+        const safeTitle = title.replace(/[<>:"/\\|?*]/g, '').replace(/\s+/g, ' ').trim();
+        // 3. 자동 태그
+        const autoTags = autoTag(transcript);
+        const allTags = [...new Set([...userTags, ...autoTags, 'voice'])];
+        // 4. frontmatter + 마크다운 생성
+        const date = new Date().toISOString();
+        const content = [
+            '---',
+            `title: "${safeTitle}"`,
+            `source: voice`,
+            `type: ${type}`,
+            `tags: [${allTags.map(t => `"${t}"`).join(', ')}]`,
+            `captured: ${date}`,
+            `audio: ${basename(audioPath)}`,
+            '---',
+            '',
+            `# ${safeTitle}`,
+            '',
+            `> Voice capture: ${date.slice(0, 10)}`,
+            '',
+            transcript,
+            '',
+        ].join('\n');
+        // 5. vault에 저장
+        const dir = join(vaultPath, folder);
+        mkdirSync(dir, { recursive: true });
+        const filePath = join(dir, `${date.slice(0, 10)} ${safeTitle}.md`);
+        writeFileSync(filePath, content, 'utf-8');
+        return {
+            title: safeTitle,
+            filePath,
+            transcript,
+            tags: allTags,
+            success: true,
+        };
+    }
+    catch (err) {
+        return {
+            title: '',
+            filePath: '',
+            transcript: '',
+            tags: [],
+            success: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+//# sourceMappingURL=voice.js.map

package/packages/core/{src/cloud/index.ts → dist/cloud/index.d.ts}

@@ -1,2 +1,3 @@
 export { syncToCloud, restoreFromCloud, getSyncState, encrypt, decrypt, getOrCreateEncryptionKey } from './sync.js';
 export type { CloudConfig, SyncResult } from './sync.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/core/dist/cloud/index.js

@@ -0,0 +1,2 @@
+export { syncToCloud, restoreFromCloud, getSyncState, encrypt, decrypt, getOrCreateEncryptionKey } from './sync.js';
+//# sourceMappingURL=index.js.map

package/packages/core/dist/cloud/sync.d.ts

@@ -0,0 +1,29 @@
+export interface CloudConfig {
+    endpoint: string;
+    bucket: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    encryptionKey?: string;
+}
+export interface SyncResult {
+    action: 'upload' | 'download';
+    dbSize: number;
+    encryptedSize: number;
+    timestamp: string;
+    success: boolean;
+    error?: string;
+}
+export declare function encrypt(data: Buffer, key: Buffer): {
+    encrypted: Buffer;
+    iv: Buffer;
+    tag: Buffer;
+};
+export declare function decrypt(encrypted: Buffer, key: Buffer, iv: Buffer, tag: Buffer): Buffer;
+export declare function getOrCreateEncryptionKey(userKey?: string): Buffer;
+export declare function syncToCloud(dbPath: string, config: CloudConfig): Promise<SyncResult>;
+export declare function restoreFromCloud(dbPath: string, config: CloudConfig): Promise<SyncResult>;
+export declare function getSyncState(): {
+    lastSync: string;
+    dbSize: number;
+} | null;
+//# sourceMappingURL=sync.d.ts.map

package/packages/core/dist/cloud/sync.js

@@ -0,0 +1,137 @@
+// Cloud Sync (F-A04) — E2E encrypted SQLite backup
+// 서버리스: S3-compatible API로 직접 업로드 (R2, S3, MinIO)
+// Design Ref: PRD §7.1 Tier 2
+import { createCipheriv, createDecipheriv, randomBytes, createHash } from 'node:crypto';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const CLOUD_DIR = join(homedir(), '.stellavault', 'cloud');
+const KEY_FILE = join(CLOUD_DIR, 'encryption.key');
+const SYNC_STATE_FILE = join(CLOUD_DIR, 'sync-state.json');
+// AES-256-GCM 암호화
+export function encrypt(data, key) {
+    const iv = randomBytes(16);
+    const cipher = createCipheriv('aes-256-gcm', key, iv);
+    const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return { encrypted, iv, tag };
+}
+export function decrypt(encrypted, key, iv, tag) {
+    const decipher = createDecipheriv('aes-256-gcm', key, iv);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(encrypted), decipher.final()]);
+}
+// 암호화 키 관리
+export function getOrCreateEncryptionKey(userKey) {
+    mkdirSync(CLOUD_DIR, { recursive: true });
+    if (userKey) {
+        const key = createHash('sha256').update(userKey).digest();
+        writeFileSync(KEY_FILE, key.toString('hex'), 'utf-8');
+        return key;
+    }
+    if (existsSync(KEY_FILE)) {
+        return Buffer.from(readFileSync(KEY_FILE, 'utf-8').trim(), 'hex');
+    }
+    const key = randomBytes(32);
+    writeFileSync(KEY_FILE, key.toString('hex'), { encoding: 'utf-8', mode: 0o600 });
+    try {
+        chmodSync(KEY_FILE, 0o600);
+    }
+    catch { /* Windows may not support */ }
+    return key;
+}
+// S3-compatible upload (presigned 불필요 — 직접 PUT)
+async function s3Put(config, objectKey, data, contentType = 'application/octet-stream') {
+    const { endpoint, bucket, accessKeyId, secretAccessKey } = config;
+    // HIGH-05: endpoint 검증
+    try {
+        const parsed = new URL(endpoint);
+        if (!['http:', 'https:'].includes(parsed.protocol))
+            throw new Error('Invalid protocol');
+        if (parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1')
+            throw new Error('Local endpoint');
+    }
+    catch (e) {
+        throw new Error(`Invalid cloud endpoint: ${endpoint}. ${e instanceof Error ? e.message : ''}`);
+    }
+    const url = `${endpoint}/${bucket}/${objectKey}`;
+    const date = new Date().toISOString().replace(/[-:]/g, '').slice(0, 15) + 'Z';
+    const res = await fetch(url, {
+        method: 'PUT',
+        headers: {
+            'Content-Type': contentType,
+            'Content-Length': String(data.length),
+            'x-amz-date': date,
+            'x-amz-content-sha256': createHash('sha256').update(data).digest('hex'),
+            // R2는 Bearer token 지원
+            'Authorization': `Bearer ${secretAccessKey}`,
+        },
+        body: data,
+    });
+    return res.ok;
+}
+async function s3Get(config, objectKey) {
+    const url = `${config.endpoint}/${config.bucket}/${objectKey}`;
+    const res = await fetch(url, {
+        headers: { 'Authorization': `Bearer ${config.secretAccessKey}` },
+    });
+    if (!res.ok)
+        return null;
+    return Buffer.from(await res.arrayBuffer());
+}
+// Sync: 로컬 DB → 암호화 → 업로드
+export async function syncToCloud(dbPath, config) {
+    const timestamp = new Date().toISOString();
+    try {
+        if (!existsSync(dbPath)) {
+            return { action: 'upload', dbSize: 0, encryptedSize: 0, timestamp, success: false, error: 'DB not found' };
+        }
+        const dbData = readFileSync(dbPath);
+        const key = getOrCreateEncryptionKey(config.encryptionKey);
+        const { encrypted, iv, tag } = encrypt(dbData, key);
+        // 패키징: [iv(16)] + [tag(16)] + [encrypted data]
+        const payload = Buffer.concat([iv, tag, encrypted]);
+        const objectKey = `stellavault/index.db.enc`;
+        const success = await s3Put(config, objectKey, payload);
+        // 동기화 상태 저장
+        const state = { lastSync: timestamp, dbSize: dbData.length, encryptedSize: payload.length, objectKey };
+        mkdirSync(CLOUD_DIR, { recursive: true });
+        writeFileSync(SYNC_STATE_FILE, JSON.stringify(state, null, 2), 'utf-8');
+        return { action: 'upload', dbSize: dbData.length, encryptedSize: payload.length, timestamp, success };
+    }
+    catch (err) {
+        return { action: 'upload', dbSize: 0, encryptedSize: 0, timestamp, success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+// Restore: 다운로드 → 복호화 → 로컬 DB 덮어쓰기
+export async function restoreFromCloud(dbPath, config) {
+    const timestamp = new Date().toISOString();
+    try {
+        const objectKey = `stellavault/index.db.enc`;
+        const payload = await s3Get(config, objectKey);
+        if (!payload) {
+            return { action: 'download', dbSize: 0, encryptedSize: 0, timestamp, success: false, error: 'No backup found in cloud' };
+        }
+        const key = getOrCreateEncryptionKey(config.encryptionKey);
+        const iv = payload.subarray(0, 16);
+        const tag = payload.subarray(16, 32);
+        const encrypted = payload.subarray(32);
+        const dbData = decrypt(encrypted, key, iv, tag);
+        // 백업 후 덮어쓰기
+        if (existsSync(dbPath)) {
+            writeFileSync(dbPath + '.backup', readFileSync(dbPath));
+        }
+        writeFileSync(dbPath, dbData);
+        return { action: 'download', dbSize: dbData.length, encryptedSize: payload.length, timestamp, success: true };
+    }
+    catch (err) {
+        return { action: 'download', dbSize: 0, encryptedSize: 0, timestamp, success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+// 동기화 상태 조회
+export function getSyncState() {
+    if (!existsSync(SYNC_STATE_FILE))
+        return null;
+    return JSON.parse(readFileSync(SYNC_STATE_FILE, 'utf-8'));
+}
+//# sourceMappingURL=sync.js.map

package/packages/core/dist/config.d.ts

@@ -0,0 +1,27 @@
+export interface StellavaultConfig {
+    vaultPath: string;
+    dbPath: string;
+    embedding: {
+        model: 'local' | 'openai';
+        localModel: string;
+    };
+    chunking: {
+        maxTokens: number;
+        overlap: number;
+        minTokens: number;
+    };
+    search: {
+        defaultLimit: number;
+        rrfK: number;
+    };
+    mcp: {
+        mode: 'stdio' | 'sse';
+        port: number;
+    };
+}
+/**
+ * .stellavault.json 파일을 찾아 로드합니다.
+ * 탐색 순서: cwd → home directory → defaults
+ */
+export declare function loadConfig(configPath?: string): StellavaultConfig;
+//# sourceMappingURL=config.d.ts.map

package/packages/core/dist/config.js

@@ -0,0 +1,55 @@
+// Design Ref: §10.2 — 설정 파일 구조 (.stellavault.json 로더)
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import { homedir } from 'node:os';
+const DEFAULT_CONFIG = {
+    vaultPath: '',
+    dbPath: join(homedir(), '.stellavault', 'index.db'),
+    embedding: {
+        model: 'local',
+        localModel: 'all-MiniLM-L6-v2',
+    },
+    chunking: {
+        maxTokens: 300,
+        overlap: 50,
+        minTokens: 50,
+    },
+    search: {
+        defaultLimit: 10,
+        rrfK: 60,
+    },
+    mcp: {
+        mode: 'stdio',
+        port: 3333,
+    },
+};
+/**
+ * .stellavault.json 파일을 찾아 로드합니다.
+ * 탐색 순서: cwd → home directory → defaults
+ */
+export function loadConfig(configPath) {
+    const paths = configPath
+        ? [resolve(configPath)]
+        : [
+            resolve(process.cwd(), '.stellavault.json'),
+            join(homedir(), '.stellavault.json'),
+        ];
+    for (const p of paths) {
+        if (existsSync(p)) {
+            const raw = JSON.parse(readFileSync(p, 'utf-8'));
+            return mergeConfig(DEFAULT_CONFIG, raw);
+        }
+    }
+    return { ...DEFAULT_CONFIG };
+}
+function mergeConfig(defaults, overrides) {
+    return {
+        vaultPath: overrides.vaultPath ?? defaults.vaultPath,
+        dbPath: overrides.dbPath ?? defaults.dbPath,
+        embedding: { ...defaults.embedding, ...overrides.embedding },
+        chunking: { ...defaults.chunking, ...overrides.chunking },
+        search: { ...defaults.search, ...overrides.search },
+        mcp: { ...defaults.mcp, ...overrides.mcp },
+    };
+}
+//# sourceMappingURL=config.js.map

package/packages/core/dist/federation/credits.d.ts

@@ -0,0 +1,26 @@
+export interface CreditAccount {
+    balance: number;
+    totalEarned: number;
+    totalSpent: number;
+    transactions: CreditTransaction[];
+}
+export interface CreditTransaction {
+    type: 'earn' | 'spend';
+    amount: number;
+    reason: string;
+    timestamp: string;
+}
+export declare function getBalance(): number;
+export declare function getAccount(): CreditAccount;
+export declare function earn(amount: number, reason: string): number;
+export declare function spend(amount: number, reason: string): {
+    success: boolean;
+    balance: number;
+};
+export declare function earnForSearchResponse(peerId: string): number;
+export declare function spendForSearch(peerCount: number): {
+    success: boolean;
+    balance: number;
+};
+export declare function getRecentTransactions(limit?: number): CreditTransaction[];
+//# sourceMappingURL=credits.d.ts.map

package/packages/core/dist/federation/credits.js

@@ -0,0 +1,56 @@
+// Federation Phase 2: Search Credits
+// 지식 공유 = 크레딧 획득, 연합 검색 = 크레딧 소모
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const CREDITS_FILE = join(homedir(), '.stellavault', 'federation', 'credits.json');
+const INITIAL_BALANCE = 100;
+const EARN_PER_SEARCH_RESPONSE = 10; // 검색 응답 시 획득
+const COST_PER_SEARCH = 1; // 검색 요청 시 소모
+function loadAccount() {
+    if (existsSync(CREDITS_FILE)) {
+        return JSON.parse(readFileSync(CREDITS_FILE, 'utf-8'));
+    }
+    return { balance: INITIAL_BALANCE, totalEarned: 0, totalSpent: 0, transactions: [] };
+}
+function saveAccount(account) {
+    mkdirSync(join(homedir(), '.stellavault', 'federation'), { recursive: true });
+    // 최근 100개 트랜잭션만 유지
+    account.transactions = account.transactions.slice(-100);
+    writeFileSync(CREDITS_FILE, JSON.stringify(account, null, 2), 'utf-8');
+}
+export function getBalance() {
+    return loadAccount().balance;
+}
+export function getAccount() {
+    return loadAccount();
+}
+export function earn(amount, reason) {
+    const account = loadAccount();
+    account.balance += amount;
+    account.totalEarned += amount;
+    account.transactions.push({ type: 'earn', amount, reason, timestamp: new Date().toISOString() });
+    saveAccount(account);
+    return account.balance;
+}
+export function spend(amount, reason) {
+    const account = loadAccount();
+    if (account.balance < amount) {
+        return { success: false, balance: account.balance };
+    }
+    account.balance -= amount;
+    account.totalSpent += amount;
+    account.transactions.push({ type: 'spend', amount, reason, timestamp: new Date().toISOString() });
+    saveAccount(account);
+    return { success: true, balance: account.balance };
+}
+export function earnForSearchResponse(peerId) {
+    return earn(EARN_PER_SEARCH_RESPONSE, `Search response to ${peerId}`);
+}
+export function spendForSearch(peerCount) {
+    return spend(COST_PER_SEARCH * peerCount, `Search across ${peerCount} peers`);
+}
+export function getRecentTransactions(limit = 20) {
+    return loadAccount().transactions.slice(-limit).reverse();
+}
+//# sourceMappingURL=credits.js.map

package/packages/core/dist/federation/identity.d.ts

@@ -0,0 +1,14 @@
+export interface NodeIdentity {
+    peerId: string;
+    publicKey: Buffer;
+    secretKey: Buffer;
+    displayName: string;
+    createdAt: string;
+}
+export declare function getOrCreateIdentity(displayName?: string): NodeIdentity;
+export declare function signMessage(secretKey: Buffer, message: Buffer): Buffer;
+export declare function verifySignature(publicKey: Buffer, secretKey: Buffer, message: Buffer, signature: Buffer): boolean;
+export declare function createChallenge(): Buffer;
+export declare function respondToChallenge(secretKey: Buffer, challenge: Buffer): Buffer;
+export declare function verifyChallenge(secretKey: Buffer, challenge: Buffer, response: Buffer): boolean;
+//# sourceMappingURL=identity.d.ts.map

package/packages/core/dist/federation/identity.js

@@ -0,0 +1,74 @@
+// Federation: Node Identity (HMAC-SHA256 signing)
+// CRIT-01 fix: 실제 서명 검증 구현 (placeholder 제거)
+// CRIT-04 fix: 키 파일 권한 0o600
+import { randomBytes, createHash, createHmac } from 'node:crypto';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const IDENTITY_DIR = join(homedir(), '.stellavault', 'federation');
+const IDENTITY_FILE = join(IDENTITY_DIR, 'identity.json');
+export function getOrCreateIdentity(displayName) {
+    if (existsSync(IDENTITY_FILE)) {
+        const raw = JSON.parse(readFileSync(IDENTITY_FILE, 'utf-8'));
+        return {
+            peerId: raw.peerId,
+            publicKey: Buffer.from(raw.publicKey, 'hex'),
+            secretKey: Buffer.from(raw.secretKey, 'hex'),
+            displayName: raw.displayName,
+            createdAt: raw.createdAt,
+        };
+    }
+    const secretKey = randomBytes(32);
+    const publicKey = createHash('sha256').update(secretKey).digest();
+    const peerId = createHash('sha256').update(publicKey).digest('hex').slice(0, 16);
+    const identity = {
+        peerId,
+        publicKey,
+        secretKey,
+        displayName: displayName ?? `node-${peerId.slice(0, 6)}`,
+        createdAt: new Date().toISOString(),
+    };
+    mkdirSync(IDENTITY_DIR, { recursive: true });
+    const content = JSON.stringify({
+        peerId: identity.peerId,
+        publicKey: publicKey.toString('hex'),
+        secretKey: secretKey.toString('hex'),
+        displayName: identity.displayName,
+        createdAt: identity.createdAt,
+    }, null, 2);
+    writeFileSync(IDENTITY_FILE, content, { encoding: 'utf-8', mode: 0o600 });
+    try {
+        chmodSync(IDENTITY_FILE, 0o600);
+    }
+    catch { /* Windows may not support */ }
+    return identity;
+}
+// CRIT-01 fix: 실제 HMAC-SHA256 서명
+export function signMessage(secretKey, message) {
+    return createHmac('sha256', secretKey).update(message).digest();
+}
+// CRIT-01 fix: 실제 HMAC-SHA256 검증
+export function verifySignature(publicKey, secretKey, message, signature) {
+    const expected = createHmac('sha256', secretKey).update(message).digest();
+    if (expected.length !== signature.length)
+        return false;
+    // Timing-safe comparison
+    let diff = 0;
+    for (let i = 0; i < expected.length; i++) {
+        diff |= expected[i] ^ signature[i];
+    }
+    return diff === 0;
+}
+// Challenge-response 인증용 nonce 생성
+export function createChallenge() {
+    return randomBytes(32);
+}
+// Challenge에 대한 응답 생성
+export function respondToChallenge(secretKey, challenge) {
+    return signMessage(secretKey, challenge);
+}
+// Challenge 응답 검증
+export function verifyChallenge(secretKey, challenge, response) {
+    return verifySignature(Buffer.alloc(0), secretKey, challenge, response);
+}
+//# sourceMappingURL=identity.js.map

package/packages/core/{src/federation/index.ts → dist/federation/index.d.ts}

@@ -1,8 +1,7 @@
-// Design Ref: §2.3 — Federation Public API
-
 export { FederationNode } from './node.js';
 export { FederatedSearch } from './search.js';
 export type { FederatedSearchOptions } from './search.js';
 export { getOrCreateIdentity } from './identity.js';
 export type { NodeIdentity } from './identity.js';
 export type { PeerInfo, FederatedSearchResult, FederationMessage } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/core/dist/federation/index.js

@@ -0,0 +1,5 @@
+// Design Ref: §2.3 — Federation Public API
+export { FederationNode } from './node.js';
+export { FederatedSearch } from './search.js';
+export { getOrCreateIdentity } from './identity.js';
+//# sourceMappingURL=index.js.map

package/packages/core/dist/federation/node.d.ts

@@ -0,0 +1,31 @@
+import { EventEmitter } from 'node:events';
+import type { PeerInfo } from './types.js';
+export declare class FederationNode extends EventEmitter {
+    private swarm;
+    private identity;
+    private peers;
+    private running;
+    private documentCount;
+    private topTopics;
+    constructor(displayName?: string);
+    get peerId(): string;
+    get displayName(): string;
+    get peerCount(): number;
+    get isRunning(): boolean;
+    setLocalStats(documentCount: number, topTopics: string[]): void;
+    join(): Promise<void>;
+    joinDirect(host: string, port: number): Promise<void>;
+    leave(): Promise<void>;
+    getPeers(): PeerInfo[];
+    sendSearchQuery(peerId: string, queryId: string, embedding: number[], limit: number): void;
+    sendSearchResult(peerId: string, queryId: string, results: Array<{
+        title: string;
+        similarity: number;
+        snippet: string;
+    }>): void;
+    private handleConnection;
+    private validateMessage;
+    private handleMessage;
+    private sendMessage;
+}
+//# sourceMappingURL=node.d.ts.map