browzy 1.0.0

package/dist/cli/hooks/useHistory.d.ts

@@ -0,0 +1,13 @@
+export declare function useHistory(): {
+    history: string[];
+    historyIndex: number;
+    addToHistory: (input: string) => void;
+    navigateHistory: (direction: "up" | "down", currentInput: string) => string | null;
+    searchMode: boolean;
+    setSearchMode: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    searchQuery: string;
+    setSearchQuery: import("react").Dispatch<import("react").SetStateAction<string>>;
+    searchHistory: (query: string) => string[];
+    stashedInput: string;
+    setStashedInput: import("react").Dispatch<import("react").SetStateAction<string>>;
+};

package/dist/cli/hooks/useHistory.js

@@ -0,0 +1,106 @@
+import { useState, useCallback, useRef } from 'react';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const HISTORY_FILE = join(homedir(), '.browzy', 'history.json');
+const MAX_HISTORY = 500;
+function loadHistory() {
+    try {
+        if (existsSync(HISTORY_FILE)) {
+            const data = JSON.parse(readFileSync(HISTORY_FILE, 'utf-8'));
+            if (Array.isArray(data))
+                return data;
+        }
+    }
+    catch { /* ignore */ }
+    return [];
+}
+function saveHistory(items) {
+    mkdirSync(join(homedir(), '.browzy'), { recursive: true });
+    writeFileSync(HISTORY_FILE, JSON.stringify(items.slice(-MAX_HISTORY)), 'utf-8');
+}
+export function useHistory() {
+    const [history, setHistory] = useState(() => loadHistory());
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const [searchMode, setSearchMode] = useState(false);
+    const [searchQuery, setSearchQuery] = useState('');
+    const [stashedInput, setStashedInput] = useState('');
+    // Refs to avoid stale closures during rapid keypresses
+    const historyIndexRef = useRef(historyIndex);
+    historyIndexRef.current = historyIndex;
+    const historyRef = useRef(history);
+    historyRef.current = history;
+    const stashedRef = useRef(stashedInput);
+    stashedRef.current = stashedInput;
+    const addToHistory = useCallback((input) => {
+        if (!input.trim())
+            return;
+        setHistory(prev => {
+            // Deduplicate consecutive
+            if (prev[prev.length - 1] === input)
+                return prev;
+            const next = [...prev, input];
+            saveHistory(next);
+            return next;
+        });
+        setHistoryIndex(-1);
+    }, []);
+    const navigateHistory = useCallback((direction, currentInput) => {
+        const h = historyRef.current;
+        const idx = historyIndexRef.current;
+        if (h.length === 0)
+            return null;
+        if (idx === -1 && direction === 'up') {
+            setStashedInput(currentInput);
+            const newIdx = h.length - 1;
+            setHistoryIndex(newIdx);
+            historyIndexRef.current = newIdx;
+            return h[newIdx];
+        }
+        if (direction === 'up') {
+            const newIdx = Math.max(0, idx - 1);
+            setHistoryIndex(newIdx);
+            historyIndexRef.current = newIdx;
+            return h[newIdx];
+        }
+        // Down
+        if (idx >= h.length - 1) {
+            setHistoryIndex(-1);
+            historyIndexRef.current = -1;
+            return stashedRef.current;
+        }
+        const newIdx = idx + 1;
+        setHistoryIndex(newIdx);
+        historyIndexRef.current = newIdx;
+        return h[newIdx];
+    }, []);
+    const searchHistory = useCallback((query) => {
+        const h = historyRef.current;
+        if (!query)
+            return h.slice(-10).reverse();
+        const lower = query.toLowerCase();
+        const seen = new Set();
+        const results = [];
+        for (let i = h.length - 1; i >= 0 && results.length < 10; i--) {
+            const item = h[i];
+            if (item.toLowerCase().includes(lower) && !seen.has(item)) {
+                seen.add(item);
+                results.push(item);
+            }
+        }
+        return results;
+    }, []);
+    return {
+        history,
+        historyIndex,
+        addToHistory,
+        navigateHistory,
+        searchMode,
+        setSearchMode,
+        searchQuery,
+        setSearchQuery,
+        searchHistory,
+        stashedInput,
+        setStashedInput,
+    };
+}

package/dist/cli/hooks/useSession.d.ts

@@ -0,0 +1,16 @@
+import type { MessageData } from '../components/Message.js';
+export interface Session {
+    id: string;
+    messages: MessageData[];
+    createdAt: string;
+    lastUpdated: string;
+}
+export declare function useSession(): {
+    sessionId: string;
+    messages: MessageData[];
+    addMessage: (role: MessageData["role"], content: string, sources?: string[]) => MessageData;
+    setMessages: import("react").Dispatch<import("react").SetStateAction<MessageData[]>>;
+    saveSession: () => void;
+    loadLastSession: () => Session | null;
+    exportSession: (outputPath: string) => string;
+};

package/dist/cli/hooks/useSession.js

@@ -0,0 +1,133 @@
+import { useState, useCallback } from 'react';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, unlinkSync, statSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const SESSIONS_DIR = join(homedir(), '.browzy', 'sessions');
+const MAX_SESSIONS = 50;
+function generateId() {
+    return Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+}
+/**
+ * Redact sensitive patterns from exported text.
+ */
+function redactSecrets(text) {
+    return text
+        .replace(/sk-ant-[a-zA-Z0-9\-_]{20,}/g, '[REDACTED_API_KEY]')
+        .replace(/sk-[a-zA-Z0-9\-_]{48,}/g, '[REDACTED_API_KEY]')
+        .replace(/Bearer\s+[a-zA-Z0-9\-_.]{20,}/gi, 'Bearer [REDACTED]');
+}
+export function useSession() {
+    const [sessionId] = useState(() => generateId());
+    const [messages, setMessages] = useState([]);
+    const addMessage = useCallback((role, content, sources) => {
+        const msg = {
+            id: generateId(),
+            role,
+            content,
+            sources,
+            timestamp: Date.now(),
+        };
+        setMessages(prev => [...prev, msg]);
+        return msg;
+    }, []);
+    const saveSession = useCallback(() => {
+        if (messages.length === 0)
+            return;
+        mkdirSync(SESSIONS_DIR, { recursive: true });
+        const session = {
+            id: sessionId,
+            messages,
+            createdAt: messages[0]?.timestamp ? new Date(messages[0].timestamp).toISOString() : new Date().toISOString(),
+            lastUpdated: new Date().toISOString(),
+        };
+        // Atomic write: write to temp file then rename
+        const finalPath = join(SESSIONS_DIR, `${sessionId}.json`);
+        const tmpPath = finalPath + '.tmp';
+        writeFileSync(tmpPath, JSON.stringify(session, null, 2), 'utf-8');
+        const { renameSync } = require('fs');
+        try {
+            renameSync(tmpPath, finalPath);
+        }
+        catch {
+            // Fallback: direct write if rename fails (cross-device)
+            writeFileSync(finalPath, JSON.stringify(session, null, 2), 'utf-8');
+            try {
+                unlinkSync(tmpPath);
+            }
+            catch { /* ignore */ }
+        }
+        // Prune old sessions — sort by mtime, keep newest
+        try {
+            const files = readdirSync(SESSIONS_DIR)
+                .filter(f => f.endsWith('.json') && !f.endsWith('.tmp'))
+                .map(f => ({
+                name: f,
+                mtime: statSync(join(SESSIONS_DIR, f)).mtimeMs,
+            }))
+                .sort((a, b) => b.mtime - a.mtime);
+            for (const file of files.slice(MAX_SESSIONS)) {
+                try {
+                    unlinkSync(join(SESSIONS_DIR, file.name));
+                }
+                catch { /* ignore */ }
+            }
+        }
+        catch { /* ignore */ }
+    }, [sessionId, messages]);
+    const loadLastSession = useCallback(() => {
+        try {
+            if (!existsSync(SESSIONS_DIR))
+                return null;
+            const files = readdirSync(SESSIONS_DIR)
+                .filter(f => f.endsWith('.json') && !f.endsWith('.tmp'))
+                .map(f => ({
+                name: f,
+                mtime: statSync(join(SESSIONS_DIR, f)).mtimeMs,
+            }))
+                .sort((a, b) => b.mtime - a.mtime);
+            if (files.length === 0)
+                return null;
+            return JSON.parse(readFileSync(join(SESSIONS_DIR, files[0].name), 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }, []);
+    const exportSession = useCallback((outputPath) => {
+        mkdirSync(join(outputPath, '..'), { recursive: true });
+        const lines = [
+            '---',
+            `title: "browzy session ${sessionId}"`,
+            `date: "${new Date().toISOString()}"`,
+            `messageCount: ${messages.length}`,
+            '---',
+            '',
+        ];
+        for (const msg of messages) {
+            if (msg.role === 'user') {
+                lines.push(`**> ${msg.content}**`, '');
+            }
+            else if (msg.role === 'assistant') {
+                lines.push(redactSecrets(msg.content), '');
+                if (msg.sources?.length) {
+                    lines.push(`*Sources: ${msg.sources.join(', ')}*`, '');
+                }
+            }
+            else {
+                lines.push(`> ${redactSecrets(msg.content)}`, '');
+            }
+            lines.push('---', '');
+        }
+        writeFileSync(outputPath, lines.join('\n'), 'utf-8');
+        return outputPath;
+    }, [sessionId, messages]);
+    return {
+        sessionId,
+        messages,
+        addMessage,
+        setMessages,
+        saveSession,
+        loadLastSession,
+        exportSession,
+    };
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import 'dotenv/config';

package/dist/cli/index.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+import { ingestCommand } from './commands/ingest.js';
+import { compileCommand } from './commands/compile.js';
+import { queryCommand } from './commands/query.js';
+import { lintCommand } from './commands/lint.js';
+import { statusCommand } from './commands/status.js';
+import { searchCommand } from './commands/search.js';
+import { showBanner } from './banner.js';
+import { BrowzyRepl } from './repl.js';
+import { needsOnboarding, runOnboarding } from './onboarding.js';
+const program = new Command();
+program
+    .name('browzy')
+    .description('LLM-powered personal knowledge base engine')
+    .version('1.0.0');
+program.addCommand(initCommand);
+program.addCommand(ingestCommand);
+program.addCommand(compileCommand);
+program.addCommand(queryCommand);
+program.addCommand(lintCommand);
+program.addCommand(statusCommand);
+program.addCommand(searchCommand);
+// No args → interactive mode
+if (process.argv.length <= 2) {
+    (async () => {
+        if (needsOnboarding()) {
+            const success = await runOnboarding();
+            if (!success)
+                process.exit(0);
+        }
+        showBanner();
+        const repl = new BrowzyRepl();
+        repl.start();
+    })();
+}
+else {
+    program.parse();
+}

package/dist/cli/keystore.d.ts

@@ -0,0 +1,28 @@
+/**
+ * browzy.ai — API key storage.
+ *
+ * Stores API keys in ~/.browzy/keys.json with restricted permissions.
+ * Keys are loaded into memory at startup and can be added at runtime
+ * via /model without restarting.
+ */
+interface KeyStore {
+    anthropic?: string;
+    openai?: string;
+    openrouter?: string;
+}
+export declare function loadKeys(): KeyStore;
+export declare function saveKey(provider: 'anthropic' | 'openai' | 'openrouter', key: string): void;
+/**
+ * Get API key for a provider. Checks:
+ * 1. Environment variable
+ * 2. ~/.browzy/keys.json
+ */
+export declare function getKey(provider: 'anthropic' | 'openai' | 'openrouter'): string | undefined;
+/**
+ * Detect if a string looks like an API key.
+ */
+export declare function looksLikeApiKey(input: string): {
+    provider: 'anthropic' | 'openai' | 'openrouter';
+    key: string;
+} | null;
+export {};

package/dist/cli/keystore.js

@@ -0,0 +1,59 @@
+/**
+ * browzy.ai — API key storage.
+ *
+ * Stores API keys in ~/.browzy/keys.json with restricted permissions.
+ * Keys are loaded into memory at startup and can be added at runtime
+ * via /model without restarting.
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const KEYS_FILE = join(homedir(), '.browzy', 'keys.json');
+export function loadKeys() {
+    try {
+        if (existsSync(KEYS_FILE)) {
+            const parsed = JSON.parse(readFileSync(KEYS_FILE, 'utf-8'));
+            if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+                return {};
+            return parsed;
+        }
+    }
+    catch { /* ignore */ }
+    return {};
+}
+export function saveKey(provider, key) {
+    mkdirSync(join(homedir(), '.browzy'), { recursive: true });
+    const keys = loadKeys();
+    keys[provider] = key;
+    writeFileSync(KEYS_FILE, JSON.stringify(keys, null, 2), { encoding: 'utf-8', mode: 0o600 });
+    try {
+        chmodSync(KEYS_FILE, 0o600);
+    }
+    catch { /* ensure perms even if file existed */ }
+}
+/**
+ * Get API key for a provider. Checks:
+ * 1. Environment variable
+ * 2. ~/.browzy/keys.json
+ */
+export function getKey(provider) {
+    const envMap = {
+        anthropic: 'ANTHROPIC_API_KEY',
+        openai: 'OPENAI_API_KEY',
+        openrouter: 'OPENROUTER_API_KEY',
+    };
+    return process.env[envMap[provider]] || loadKeys()[provider] || undefined;
+}
+/**
+ * Detect if a string looks like an API key.
+ */
+export function looksLikeApiKey(input) {
+    const trimmed = input.trim();
+    if (trimmed.startsWith('sk-ant-'))
+        return { provider: 'anthropic', key: trimmed };
+    if (trimmed.startsWith('sk-or-'))
+        return { provider: 'openrouter', key: trimmed };
+    if (trimmed.startsWith('sk-') && trimmed.length > 30)
+        return { provider: 'openai', key: trimmed };
+    return null;
+}

package/dist/cli/onboarding.d.ts

@@ -0,0 +1,18 @@
+export interface UserProfile {
+    name: string;
+    createdAt: string;
+    lastSeen: string;
+    sessionCount: number;
+}
+export declare function loadProfile(): UserProfile | null;
+export declare function saveProfile(profile: UserProfile): void;
+export declare function touchProfile(): UserProfile | null;
+export declare function getWelcomeMessage(profile: UserProfile, stats?: {
+    sources: number;
+    articles: number;
+}): string;
+export declare function runOnboarding(): Promise<boolean>;
+/**
+ * Check if onboarding is needed (no profile exists).
+ */
+export declare function needsOnboarding(): boolean;