stellavault 0.2.0 → 0.2.1

package/packages/core/src/capture/voice.ts

@@ -1,168 +0,0 @@
-// 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: string): string {
-  if (!ALLOWED_MODELS.includes(model)) throw new Error(`Invalid model: ${model}. Allowed: ${ALLOWED_MODELS.join(', ')}`);
-  return model;
-}
-
-function validateLanguage(lang: string): string {
-  if (!ALLOWED_LANGUAGES.includes(lang)) throw new Error(`Invalid language: ${lang}. Allowed: ${ALLOWED_LANGUAGES.join(', ')}`);
-  return lang;
-}
-
-export interface CaptureResult {
-  title: string;
-  filePath: string;
-  transcript: string;
-  duration?: number;
-  tags: string[];
-  success: boolean;
-  error?: string;
-}
-
-export interface CaptureOptions {
-  vaultPath: string;
-  folder?: string;      // default: 01_Knowledge/voice
-  language?: string;     // default: auto
-  model?: string;        // whisper model: tiny, base, small, medium, large
-  tags?: string[];
-  type?: string;
-}
-
-// Whisper CLI가 설치되어 있는지 확인
-export function isWhisperAvailable(): boolean {
-  try {
-    execSync('whisper --help', { stdio: 'ignore' });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// 음성 파일 → 텍스트 변환 (Whisper CLI)
-export async function transcribeAudio(audioPath: string, options: { model?: string; language?: string } = {}): Promise<string> {
-  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: string): string[] {
-  const tags: string[] = [];
-  const lower = text.toLowerCase();
-
-  const keywords: Record<string, string[]> = {
-    '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: string, options: CaptureOptions): Promise<CaptureResult> {
-  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),
-    };
-  }
-}

package/packages/core/src/cloud/sync.ts

@@ -1,167 +0,0 @@
-// 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';
-
-export interface CloudConfig {
-  endpoint: string;    // S3-compatible endpoint (e.g., https://xxx.r2.cloudflarestorage.com)
-  bucket: string;
-  accessKeyId: string;
-  secretAccessKey: string;
-  encryptionKey?: string;  // user-provided, or auto-generated
-}
-
-export interface SyncResult {
-  action: 'upload' | 'download';
-  dbSize: number;
-  encryptedSize: number;
-  timestamp: string;
-  success: boolean;
-  error?: string;
-}
-
-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: Buffer, key: Buffer): { encrypted: Buffer; iv: Buffer; tag: Buffer } {
-  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: Buffer, key: Buffer, iv: Buffer, tag: Buffer): Buffer {
-  const decipher = createDecipheriv('aes-256-gcm', key, iv);
-  decipher.setAuthTag(tag);
-  return Buffer.concat([decipher.update(encrypted), decipher.final()]);
-}
-
-// 암호화 키 관리
-export function getOrCreateEncryptionKey(userKey?: string): Buffer {
-  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: CloudConfig, objectKey: string, data: Buffer, contentType = 'application/octet-stream'): Promise<boolean> {
-  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: CloudConfig, objectKey: string): Promise<Buffer | null> {
-  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: string, config: CloudConfig): Promise<SyncResult> {
-  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: string, config: CloudConfig): Promise<SyncResult> {
-  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(): { lastSync: string; dbSize: number } | null {
-  if (!existsSync(SYNC_STATE_FILE)) return null;
-  return JSON.parse(readFileSync(SYNC_STATE_FILE, 'utf-8'));
-}

package/packages/core/src/config.ts

@@ -1,82 +0,0 @@
-// Design Ref: §10.2 — 설정 파일 구조 (.stellavault.json 로더)
-
-import { readFileSync, existsSync } from 'node:fs';
-import { resolve, join } from 'node:path';
-import { homedir } from 'node:os';
-
-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;
-  };
-}
-
-const DEFAULT_CONFIG: StellavaultConfig = {
-  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?: string): StellavaultConfig {
-  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: StellavaultConfig, overrides: Partial<StellavaultConfig>): StellavaultConfig {
-  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 },
-  };
-}

package/packages/core/src/federation/credits.ts

@@ -1,80 +0,0 @@
-// Federation Phase 2: Search Credits
-// 지식 공유 = 크레딧 획득, 연합 검색 = 크레딧 소모
-
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-
-export interface CreditAccount {
-  balance: number;
-  totalEarned: number;
-  totalSpent: number;
-  transactions: CreditTransaction[];
-}
-
-export interface CreditTransaction {
-  type: 'earn' | 'spend';
-  amount: number;
-  reason: string;
-  timestamp: string;
-}
-
-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(): CreditAccount {
-  if (existsSync(CREDITS_FILE)) {
-    return JSON.parse(readFileSync(CREDITS_FILE, 'utf-8'));
-  }
-  return { balance: INITIAL_BALANCE, totalEarned: 0, totalSpent: 0, transactions: [] };
-}
-
-function saveAccount(account: CreditAccount): void {
-  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(): number {
-  return loadAccount().balance;
-}
-
-export function getAccount(): CreditAccount {
-  return loadAccount();
-}
-
-export function earn(amount: number, reason: string): number {
-  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: number, reason: string): { success: boolean; balance: number } {
-  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: string): number {
-  return earn(EARN_PER_SEARCH_RESPONSE, `Search response to ${peerId}`);
-}
-
-export function spendForSearch(peerCount: number): { success: boolean; balance: number } {
-  return spend(COST_PER_SEARCH * peerCount, `Search across ${peerCount} peers`);
-}
-
-export function getRecentTransactions(limit = 20): CreditTransaction[] {
-  return loadAccount().transactions.slice(-limit).reverse();
-}

package/packages/core/src/federation/hyperswarm.d.ts

@@ -1,19 +0,0 @@
-declare module 'hyperswarm' {
-  import { EventEmitter } from 'events';
-
-  interface HyperswarmOptions {
-    maxPeers?: number;
-  }
-
-  interface Discovery {
-    flushed(): Promise<void>;
-  }
-
-  class Hyperswarm extends EventEmitter {
-    constructor(options?: HyperswarmOptions);
-    join(topic: Buffer, options?: { server?: boolean; client?: boolean }): Discovery;
-    destroy(): Promise<void>;
-  }
-
-  export default Hyperswarm;
-}

package/packages/core/src/federation/identity.ts

@@ -1,90 +0,0 @@
-// 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';
-
-export interface NodeIdentity {
-  peerId: string;      // hex-encoded public key hash (first 16 chars)
-  publicKey: Buffer;
-  secretKey: Buffer;
-  displayName: string;
-  createdAt: string;
-}
-
-const IDENTITY_DIR = join(homedir(), '.stellavault', 'federation');
-const IDENTITY_FILE = join(IDENTITY_DIR, 'identity.json');
-
-export function getOrCreateIdentity(displayName?: string): NodeIdentity {
-  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: NodeIdentity = {
-    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: Buffer, message: Buffer): Buffer {
-  return createHmac('sha256', secretKey).update(message).digest();
-}
-
-// CRIT-01 fix: 실제 HMAC-SHA256 검증
-export function verifySignature(publicKey: Buffer, secretKey: Buffer, message: Buffer, signature: Buffer): boolean {
-  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(): Buffer {
-  return randomBytes(32);
-}
-
-// Challenge에 대한 응답 생성
-export function respondToChallenge(secretKey: Buffer, challenge: Buffer): Buffer {
-  return signMessage(secretKey, challenge);
-}
-
-// Challenge 응답 검증
-export function verifyChallenge(secretKey: Buffer, challenge: Buffer, response: Buffer): boolean {
-  return verifySignature(Buffer.alloc(0), secretKey, challenge, response);
-}