stellavault 0.2.0 → 0.3.0

package/packages/core/dist/store/sqlite-vec.js

@@ -0,0 +1,251 @@
+// Design Ref: §3.3 — SQLite-vec 스키마
+// Design Ref: §3.2 — VectorStore 인터페이스 구현
+import Database from 'better-sqlite3';
+import * as sqliteVec from 'sqlite-vec';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+export function createSqliteVecStore(dbPath, dimensions = 384) {
+    let db;
+    return {
+        async initialize() {
+            mkdirSync(dirname(dbPath), { recursive: true });
+            db = new Database(dbPath);
+            sqliteVec.load(db);
+            db.pragma('journal_mode = WAL');
+            db.pragma('foreign_keys = ON');
+            createTables(db, dimensions);
+        },
+        async upsertDocument(doc) {
+            db.prepare(`
+        INSERT OR REPLACE INTO documents (id, file_path, title, content, frontmatter, tags, last_modified, content_hash, indexed_at, source, type)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(doc.id, doc.filePath, doc.title, doc.content, JSON.stringify(doc.frontmatter), JSON.stringify(doc.tags), doc.lastModified, doc.contentHash, new Date().toISOString(), doc.source ?? 'local', doc.type ?? 'note');
+        },
+        async upsertChunks(chunks) {
+            if (chunks.length === 0)
+                return;
+            const docId = chunks[0].documentId;
+            const tx = db.transaction(() => {
+                // 기존 청크 삭제 (문서 단위 교체)
+                // 새로 삽입할 chunk ID들도 미리 삭제 (다른 문서에서 온 중복 방지)
+                const newChunkIds = chunks.map(c => c.id);
+                db.prepare('DELETE FROM chunk_embeddings WHERE chunk_id IN (SELECT id FROM chunks WHERE document_id = ?)').run(docId);
+                db.prepare('DELETE FROM chunks WHERE document_id = ?').run(docId);
+                for (const cid of newChunkIds) {
+                    db.prepare('DELETE FROM chunk_embeddings WHERE chunk_id = ?').run(cid);
+                    db.prepare('DELETE FROM chunks WHERE id = ?').run(cid);
+                }
+                const insertChunk = db.prepare(`
+          INSERT INTO chunks (id, document_id, content, heading, start_line, end_line, token_count)
+          VALUES (?, ?, ?, ?, ?, ?, ?)
+        `);
+                const insertEmbedding = db.prepare(`
+          INSERT INTO chunk_embeddings (chunk_id, embedding)
+          VALUES (?, ?)
+        `);
+                for (const chunk of chunks) {
+                    insertChunk.run(chunk.id, chunk.documentId, chunk.content, chunk.heading, chunk.startLine, chunk.endLine, chunk.tokenCount);
+                    if (chunk.embedding) {
+                        insertEmbedding.run(chunk.id, float32Buffer(chunk.embedding));
+                    }
+                }
+            });
+            tx();
+        },
+        async deleteByDocumentId(documentId) {
+            const tx = db.transaction(() => {
+                db.prepare('DELETE FROM chunk_embeddings WHERE chunk_id IN (SELECT id FROM chunks WHERE document_id = ?)').run(documentId);
+                db.prepare('DELETE FROM chunks WHERE document_id = ?').run(documentId);
+                db.prepare('DELETE FROM documents WHERE id = ?').run(documentId);
+            });
+            tx();
+        },
+        async searchSemantic(embedding, limit) {
+            const rows = db.prepare(`
+        SELECT chunk_id, distance
+        FROM chunk_embeddings
+        WHERE embedding MATCH ?
+        ORDER BY distance
+        LIMIT ?
+      `).all(float32Buffer(embedding), limit);
+            return rows.map(r => ({
+                chunkId: r.chunk_id,
+                score: 1 / (1 + r.distance), // distance → similarity score
+            }));
+        },
+        async searchKeyword(query, limit) {
+            const rows = db.prepare(`
+        SELECT c.id as chunk_id, rank
+        FROM chunks_fts f
+        JOIN chunks c ON c.rowid = f.rowid
+        WHERE chunks_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `).all(query, limit);
+            return rows.map(r => ({
+                chunkId: r.chunk_id,
+                score: -r.rank, // FTS5 rank is negative (lower = better)
+            }));
+        },
+        async getDocument(documentId) {
+            const row = db.prepare('SELECT * FROM documents WHERE id = ?').get(documentId);
+            if (!row)
+                return null;
+            return rowToDocument(row);
+        },
+        async getChunk(chunkId) {
+            const row = db.prepare('SELECT * FROM chunks WHERE id = ?').get(chunkId);
+            if (!row)
+                return null;
+            return rowToChunk(row);
+        },
+        async getAllDocuments() {
+            const rows = db.prepare('SELECT * FROM documents ORDER BY last_modified DESC').all();
+            return rows.map(rowToDocument);
+        },
+        async getTopics() {
+            const rows = db.prepare(`
+        SELECT je.value as tag, COUNT(DISTINCT d.id) as count
+        FROM documents d, json_each(d.tags) je
+        GROUP BY je.value
+        ORDER BY count DESC
+      `).all();
+            return rows.map(r => ({
+                topic: r.tag,
+                count: r.count,
+                recentDocuments: [],
+            }));
+        },
+        async getStats() {
+            const docCount = db.prepare('SELECT COUNT(*) as c FROM documents').get().c;
+            const chunkCount = db.prepare('SELECT COUNT(*) as c FROM chunks').get().c;
+            const lastRow = db.prepare('SELECT indexed_at FROM documents ORDER BY indexed_at DESC LIMIT 1').get();
+            return {
+                documentCount: docCount,
+                chunkCount: chunkCount,
+                dbSizeBytes: 0, // 나중에 파일 크기 조회
+                lastIndexed: lastRow?.indexed_at ?? null,
+            };
+        },
+        async getDocumentEmbeddings() {
+            // 각 문서의 첫 청크 임베딩을 문서 대표 벡터로 사용
+            const rows = db.prepare(`
+        SELECT c.document_id, ce.embedding
+        FROM chunks c
+        JOIN chunk_embeddings ce ON ce.chunk_id = c.id
+        WHERE c.id IN (
+          SELECT MIN(id) FROM chunks GROUP BY document_id
+        )
+      `).all();
+            const result = new Map();
+            for (const row of rows) {
+                result.set(row.document_id, bufferToFloat32(row.embedding));
+            }
+            return result;
+        },
+        async close() {
+            db.close();
+        },
+        getDb() {
+            return db;
+        },
+    };
+}
+function bufferToFloat32(buf) {
+    const float32 = new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
+    return Array.from(float32);
+}
+function createTables(db, dimensions = 384) {
+    // 기존 DB 마이그레이션: source/type 컬럼 추가
+    try {
+        db.exec(`ALTER TABLE documents ADD COLUMN source TEXT DEFAULT 'local'`);
+    }
+    catch { /* 이미 존재 */ }
+    try {
+        db.exec(`ALTER TABLE documents ADD COLUMN type TEXT DEFAULT 'note'`);
+    }
+    catch { /* 이미 존재 */ }
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS documents (
+      id TEXT PRIMARY KEY,
+      file_path TEXT NOT NULL UNIQUE,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      frontmatter TEXT,
+      tags TEXT DEFAULT '[]',
+      last_modified TEXT NOT NULL,
+      content_hash TEXT NOT NULL,
+      indexed_at TEXT NOT NULL,
+      source TEXT DEFAULT 'local',
+      type TEXT DEFAULT 'note'
+    );
+
+    CREATE TABLE IF NOT EXISTS chunks (
+      id TEXT PRIMARY KEY,
+      document_id TEXT NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
+      content TEXT NOT NULL,
+      heading TEXT,
+      start_line INTEGER,
+      end_line INTEGER,
+      token_count INTEGER
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS chunk_embeddings USING vec0(
+      chunk_id TEXT PRIMARY KEY,
+      embedding FLOAT[${dimensions}]
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+      content,
+      heading,
+      content='chunks',
+      content_rowid='rowid'
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_chunks_document_id ON chunks(document_id);
+    CREATE INDEX IF NOT EXISTS idx_documents_content_hash ON documents(content_hash);
+  `);
+    // FTS5 트리거: chunks INSERT/DELETE 시 자동 동기화
+    db.exec(`
+    CREATE TRIGGER IF NOT EXISTS chunks_ai AFTER INSERT ON chunks BEGIN
+      INSERT INTO chunks_fts(rowid, content, heading) VALUES (new.rowid, new.content, new.heading);
+    END;
+    CREATE TRIGGER IF NOT EXISTS chunks_ad AFTER DELETE ON chunks BEGIN
+      INSERT INTO chunks_fts(chunks_fts, rowid, content, heading) VALUES('delete', old.rowid, old.content, old.heading);
+    END;
+  `);
+}
+// Document 헬퍼: upsertDocument는 indexer에서 호출
+export function upsertDocument(db, doc) {
+    db.prepare(`
+    INSERT OR REPLACE INTO documents (id, file_path, title, content, frontmatter, tags, last_modified, content_hash, indexed_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(doc.id, doc.filePath, doc.title, doc.content, JSON.stringify(doc.frontmatter), JSON.stringify(doc.tags), doc.lastModified, doc.contentHash, new Date().toISOString());
+}
+function rowToDocument(row) {
+    return {
+        id: row.id,
+        filePath: row.file_path,
+        title: row.title,
+        content: row.content,
+        frontmatter: JSON.parse(row.frontmatter || '{}'),
+        tags: JSON.parse(row.tags || '[]'),
+        lastModified: row.last_modified,
+        contentHash: row.content_hash,
+    };
+}
+function rowToChunk(row) {
+    return {
+        id: row.id,
+        documentId: row.document_id,
+        content: row.content,
+        heading: row.heading ?? '',
+        startLine: row.start_line,
+        endLine: row.end_line,
+        tokenCount: row.token_count,
+    };
+}
+function float32Buffer(arr) {
+    return Buffer.from(new Float32Array(arr).buffer);
+}
+//# sourceMappingURL=sqlite-vec.js.map

package/packages/core/dist/store/types.d.ts

@@ -0,0 +1,20 @@
+import type { Chunk, ScoredChunk, Document, TopicInfo, StoreStats } from '../types/index.js';
+export interface VectorStore {
+    initialize(): Promise<void>;
+    upsertDocument(doc: Document): Promise<void>;
+    upsertChunks(chunks: Chunk[]): Promise<void>;
+    deleteByDocumentId(documentId: string): Promise<void>;
+    searchSemantic(embedding: number[], limit: number): Promise<ScoredChunk[]>;
+    searchKeyword(query: string, limit: number): Promise<ScoredChunk[]>;
+    getDocument(documentId: string): Promise<Document | null>;
+    getChunk(chunkId: string): Promise<Chunk | null>;
+    getAllDocuments(): Promise<Document[]>;
+    getTopics(): Promise<TopicInfo[]>;
+    getStats(): Promise<StoreStats>;
+    /** 각 문서의 첫 청크 임베딩 반환 (graph용) */
+    getDocumentEmbeddings(): Promise<Map<string, number[]>>;
+    close(): Promise<void>;
+    /** 내부 DB 인스턴스 접근 (Intelligence Layer용) */
+    getDb(): unknown;
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/core/dist/store/types.js

@@ -0,0 +1,3 @@
+// Design Ref: §3.2 — 교체 가능 설계 (VectorStore 인터페이스)
+export {};
+//# sourceMappingURL=types.js.map

package/packages/core/dist/team/index.d.ts

@@ -0,0 +1,25 @@
+export type TeamRole = 'admin' | 'editor' | 'viewer';
+export interface TeamMember {
+    token: string;
+    tokenHash: string;
+    displayName: string;
+    role: TeamRole;
+    createdAt: string;
+    lastAccess?: string;
+}
+export interface TeamConfig {
+    teamName: string;
+    members: TeamMember[];
+}
+export declare function loadTeamConfig(): TeamConfig;
+export declare function generateToken(): string;
+export declare function inviteMember(displayName: string, role?: TeamRole): {
+    token: string;
+    member: TeamMember;
+};
+export declare function authenticateMember(token: string): TeamMember | null;
+export declare function hasPermission(member: TeamMember, action: 'read' | 'write' | 'admin'): boolean;
+export declare function listMembers(): TeamMember[];
+export declare function removeMember(displayName: string): boolean;
+export declare function createAuthMiddleware(): (req: any, res: any, next: any) => any;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,97 @@
+// Team Vault (F-A06) — Bearer 토큰 인증 + RBAC
+// MCP Streamable HTTP에 인증 레이어 추가
+import { randomBytes, createHash } from 'node:crypto';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const TEAM_DIR = join(homedir(), '.stellavault', 'team');
+const TEAM_FILE = join(TEAM_DIR, 'team.json');
+export function loadTeamConfig() {
+    if (existsSync(TEAM_FILE)) {
+        return JSON.parse(readFileSync(TEAM_FILE, 'utf-8'));
+    }
+    return { teamName: 'My Team', members: [] };
+}
+function saveTeamConfig(config) {
+    mkdirSync(TEAM_DIR, { recursive: true });
+    writeFileSync(TEAM_FILE, JSON.stringify(config, null, 2), 'utf-8');
+}
+// 토큰 생성
+export function generateToken() {
+    return `sv_${randomBytes(24).toString('hex')}`;
+}
+function hashToken(token) {
+    return createHash('sha256').update(token).digest('hex');
+}
+// 멤버 초대 → 토큰 반환
+export function inviteMember(displayName, role = 'viewer') {
+    const config = loadTeamConfig();
+    const token = generateToken();
+    const member = {
+        token: '', // 클리어 토큰은 저장 안 함
+        tokenHash: hashToken(token),
+        displayName,
+        role,
+        createdAt: new Date().toISOString(),
+    };
+    config.members.push(member);
+    saveTeamConfig(config);
+    return { token, member }; // 토큰은 이때만 보여줌
+}
+// 토큰으로 멤버 인증
+export function authenticateMember(token) {
+    const config = loadTeamConfig();
+    const hash = hashToken(token);
+    const member = config.members.find(m => m.tokenHash === hash);
+    if (member) {
+        member.lastAccess = new Date().toISOString();
+        saveTeamConfig(config);
+    }
+    return member ?? null;
+}
+// RBAC 권한 확인
+export function hasPermission(member, action) {
+    switch (action) {
+        case 'read': return true; // 모든 역할 읽기 가능
+        case 'write': return member.role === 'admin' || member.role === 'editor';
+        case 'admin': return member.role === 'admin';
+    }
+}
+// 멤버 목록
+export function listMembers() {
+    return loadTeamConfig().members;
+}
+// 멤버 제거
+export function removeMember(displayName) {
+    const config = loadTeamConfig();
+    const before = config.members.length;
+    config.members = config.members.filter(m => m.displayName !== displayName);
+    if (config.members.length < before) {
+        saveTeamConfig(config);
+        return true;
+    }
+    return false;
+}
+// Express 미들웨어: Bearer 토큰 인증
+export function createAuthMiddleware() {
+    return (req, res, next) => {
+        const authHeader = req.headers.authorization;
+        if (!authHeader?.startsWith('Bearer ')) {
+            // HIGH-01: localhost는 editor 권한만 (admin은 토큰 필수)
+            const ip = req.ip || req.connection?.remoteAddress;
+            if (ip === '127.0.0.1' || ip === '::1' || ip === '::ffff:127.0.0.1') {
+                req.teamMember = { displayName: 'local', role: 'editor' };
+                return next();
+            }
+            return res.status(401).json({ error: 'Bearer token required' });
+        }
+        const token = authHeader.slice(7);
+        const member = authenticateMember(token);
+        if (!member) {
+            return res.status(403).json({ error: 'Invalid token' });
+        }
+        req.teamMember = member;
+        next();
+    };
+}
+//# sourceMappingURL=index.js.map

package/packages/core/dist/types/chunk.d.ts

@@ -0,0 +1,23 @@
+export interface Chunk {
+    /** document.id + "#" + chunkIndex */
+    id: string;
+    /** 소속 문서 ID */
+    documentId: string;
+    /** 청크 텍스트 */
+    content: string;
+    /** 소속 heading (## 제목) */
+    heading: string;
+    /** 원문 시작 줄 번호 */
+    startLine: number;
+    /** 원문 끝 줄 번호 */
+    endLine: number;
+    /** 토큰 수 */
+    tokenCount: number;
+    /** 768차원 벡터 (로딩 시 선택적) */
+    embedding?: number[];
+}
+export interface ScoredChunk {
+    chunkId: string;
+    score: number;
+}
+//# sourceMappingURL=chunk.d.ts.map

package/packages/core/dist/types/chunk.js

@@ -0,0 +1,3 @@
+// Design Ref: §3.1 — Core Types (Chunk)
+export {};
+//# sourceMappingURL=chunk.js.map

package/packages/core/dist/types/document.d.ts

@@ -0,0 +1,23 @@
+export interface Document {
+    /** SHA-256 hash of file path */
+    id: string;
+    /** vault 기준 상대 경로 */
+    filePath: string;
+    /** frontmatter title 또는 첫 heading */
+    title: string;
+    /** 전체 마크다운 텍스트 */
+    content: string;
+    /** YAML frontmatter */
+    frontmatter: Record<string, unknown>;
+    /** #태그 목록 */
+    tags: string[];
+    /** ISO 8601 */
+    lastModified: string;
+    /** SHA-256 of content (증분 인덱싱용) */
+    contentHash: string;
+    /** 출처: local | notion | clip | bridge | pack */
+    source?: string;
+    /** 노트 유형: note | clip | sync | bridge | decision | snapshot */
+    type?: string;
+}
+//# sourceMappingURL=document.d.ts.map

package/packages/core/dist/types/document.js

@@ -0,0 +1,3 @@
+// Design Ref: §3.1 — Core Types (Document)
+export {};
+//# sourceMappingURL=document.js.map

package/packages/core/dist/types/graph.d.ts

@@ -0,0 +1,39 @@
+export interface GraphNode {
+    id: string;
+    label: string;
+    filePath: string;
+    tags: string[];
+    clusterId: number;
+    position?: [number, number, number];
+    size: number;
+    source?: string;
+    type?: string;
+    lastModified?: string;
+}
+export interface GraphEdge {
+    source: string;
+    target: string;
+    weight: number;
+}
+export interface Cluster {
+    id: number;
+    label: string;
+    color: string;
+    nodeCount: number;
+}
+export interface GraphData {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    clusters: Cluster[];
+    stats: {
+        nodeCount: number;
+        edgeCount: number;
+        clusterCount: number;
+    };
+}
+export interface GraphResponse {
+    data: GraphData;
+    generatedAt: string;
+    cacheKey: string;
+}
+//# sourceMappingURL=graph.d.ts.map

package/packages/core/dist/types/graph.js

@@ -0,0 +1,3 @@
+// Design Ref: §3.1 — Graph Data Types
+export {};
+//# sourceMappingURL=graph.js.map

package/packages/core/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export type { Document } from './document.js';
+export type { Chunk, ScoredChunk } from './chunk.js';
+export type { SearchResult, SearchOptions, TopicInfo, StoreStats, } from './search.js';
+export type { GraphNode, GraphEdge, Cluster, GraphData, GraphResponse, } from './graph.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/packages/core/dist/types/search.d.ts

@@ -0,0 +1,39 @@
+import type { Chunk } from './chunk.js';
+import type { Document } from './document.js';
+export interface SearchResult {
+    chunk: Chunk;
+    document: Document;
+    /** RRF 통합 점수 (0~1) */
+    score: number;
+    /** 매칭 부분 하이라이트 */
+    highlights: string[];
+}
+export interface SearchOptions {
+    query: string;
+    /** default: 10 */
+    limit?: number;
+    /** minimum score, default: 0.1 */
+    threshold?: number;
+    /** 태그 필터 */
+    tags?: string[];
+    /** 날짜 범위 필터 */
+    dateRange?: {
+        from?: string;
+        to?: string;
+    };
+}
+export interface TopicInfo {
+    topic: string;
+    count: number;
+    recentDocuments: Array<{
+        id: string;
+        title: string;
+    }>;
+}
+export interface StoreStats {
+    documentCount: number;
+    chunkCount: number;
+    dbSizeBytes: number;
+    lastIndexed: string | null;
+}
+//# sourceMappingURL=search.d.ts.map

package/packages/core/dist/types/search.js

@@ -0,0 +1,3 @@
+// Design Ref: §3.1 — Core Types (Search)
+export {};
+//# sourceMappingURL=search.js.map

package/packages/core/dist/utils/retry.d.ts

@@ -0,0 +1,25 @@
+export interface RetryOptions {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    onRetry?: (error: Error, attempt: number, maxRetries: number) => void;
+}
+export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+export declare class StellavaultError extends Error {
+    readonly code: string;
+    readonly suggestion?: string | undefined;
+    readonly cause?: Error | undefined;
+    constructor(message: string, code: string, suggestion?: string | undefined, cause?: Error | undefined);
+    format(): string;
+}
+export declare function wrapError(err: unknown, code: string, suggestion?: string): StellavaultError;
+export declare const errors: {
+    vaultNotFound: (path: string) => StellavaultError;
+    dbInitFailed: (err: unknown) => StellavaultError;
+    embedderFailed: (err: unknown) => StellavaultError;
+    indexingFailed: (file: string, err: unknown) => StellavaultError;
+    searchFailed: (err: unknown) => StellavaultError;
+    configInvalid: (field: string) => StellavaultError;
+    apiServerFailed: (port: number, err: unknown) => StellavaultError;
+};
+//# sourceMappingURL=retry.d.ts.map

package/packages/core/dist/utils/retry.js

@@ -0,0 +1,59 @@
+// Error Recovery System (F-A02) — retry with exponential backoff + meaningful messages
+const DEFAULT_OPTIONS = {
+    maxRetries: 3,
+    baseDelayMs: 500,
+    maxDelayMs: 10000,
+};
+export async function withRetry(fn, options = {}) {
+    const { maxRetries, baseDelayMs, maxDelayMs } = { ...DEFAULT_OPTIONS, ...options };
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err : new Error(String(err));
+            if (attempt >= maxRetries)
+                break;
+            const delay = Math.min(baseDelayMs * Math.pow(2, attempt), maxDelayMs);
+            options.onRetry?.(lastError, attempt + 1, maxRetries);
+            await new Promise((r) => setTimeout(r, delay));
+        }
+    }
+    throw lastError;
+}
+export class StellavaultError extends Error {
+    code;
+    suggestion;
+    cause;
+    constructor(message, code, suggestion, cause) {
+        super(message);
+        this.code = code;
+        this.suggestion = suggestion;
+        this.cause = cause;
+        this.name = 'StellavaultError';
+    }
+    format() {
+        const lines = [`Error [${this.code}]: ${this.message}`];
+        if (this.suggestion)
+            lines.push(`  Fix: ${this.suggestion}`);
+        if (this.cause)
+            lines.push(`  Cause: ${this.cause.message}`);
+        return lines.join('\n');
+    }
+}
+export function wrapError(err, code, suggestion) {
+    const cause = err instanceof Error ? err : new Error(String(err));
+    return new StellavaultError(cause.message, code, suggestion, cause);
+}
+// Common error factories
+export const errors = {
+    vaultNotFound: (path) => new StellavaultError(`Vault not found: ${path}`, 'VAULT_NOT_FOUND', 'Check the path exists and contains .md files'),
+    dbInitFailed: (err) => wrapError(err, 'DB_INIT_FAILED', 'Delete ~/.stellavault/index.db and re-index'),
+    embedderFailed: (err) => wrapError(err, 'EMBEDDER_FAILED', 'Check disk space and try again. The model downloads on first run (~80MB)'),
+    indexingFailed: (file, err) => wrapError(err, 'INDEX_FAILED', `Skipping "${file}". Re-run indexing to retry failed files`),
+    searchFailed: (err) => wrapError(err, 'SEARCH_FAILED', 'Re-index your vault: stellavault index <path>'),
+    configInvalid: (field) => new StellavaultError(`Invalid config: ${field}`, 'CONFIG_INVALID', 'Check ~/.stellavault.json format'),
+    apiServerFailed: (port, err) => wrapError(err, 'API_SERVER_FAILED', `Port ${port} may be in use. Try: stellavault graph --port ${port + 1}`),
+};
+//# sourceMappingURL=retry.js.map

package/.github/workflows/pages.yml

@@ -1,37 +0,0 @@
-name: Deploy Landing Page to GitHub Pages
-
-on:
-  push:
-    branches: [master]
-    paths: [docs/landing/**]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-  pages: write
-  id-token: write
-
-concurrency:
-  group: pages
-  cancel-in-progress: false
-
-jobs:
-  deploy:
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup Pages
-        uses: actions/configure-pages@v5
-
-      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
-        with:
-          path: docs/landing
-
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v4