@nandansai08/personal-ai 0.8.0

package/dist/tools/notes.js

@@ -0,0 +1,121 @@
+// MIT License — personal-ai
+import Database from 'better-sqlite3';
+import { randomUUID as uuidv4 } from 'node:crypto';
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+const DB_DIR = path.join(os.homedir(), '.personal-ai');
+const DB_PATH = path.join(DB_DIR, 'notes.db');
+function rowToNote(row) {
+    return {
+        id: row.id,
+        title: row.title,
+        content: row.content,
+        tags: JSON.parse(row.tags),
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+}
+function getDb() {
+    fs.mkdirSync(DB_DIR, { recursive: true });
+    const db = new Database(DB_PATH);
+    db.pragma('journal_mode = WAL');
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS notes (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL DEFAULT '',
+      tags TEXT NOT NULL DEFAULT '[]',
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_notes_title ON notes(title);
+  `);
+    return db;
+}
+function saveNote(title, content, tags) {
+    const db = getDb();
+    const now = new Date().toISOString();
+    const existing = db.prepare('SELECT * FROM notes WHERE title = ?').get(title);
+    if (existing) {
+        db.prepare('UPDATE notes SET content = ?, tags = ?, updated_at = ? WHERE id = ?')
+            .run(content, JSON.stringify(tags), now, existing.id);
+        return rowToNote({ ...existing, content, tags: JSON.stringify(tags), updated_at: now });
+    }
+    const id = uuidv4();
+    db.prepare('INSERT INTO notes (id,title,content,tags,created_at,updated_at) VALUES (?,?,?,?,?,?)')
+        .run(id, title, content, JSON.stringify(tags), now, now);
+    return { id, title, content, tags, created_at: now, updated_at: now };
+}
+function getNote(title) {
+    const db = getDb();
+    const row = db.prepare('SELECT * FROM notes WHERE title = ?').get(title);
+    return row ? rowToNote(row) : null;
+}
+function listNotes(tag) {
+    const db = getDb();
+    const rows = db.prepare('SELECT * FROM notes ORDER BY updated_at DESC LIMIT 50').all();
+    const notes = rows.map(rowToNote);
+    if (tag)
+        return notes.filter(n => n.tags.includes(tag));
+    return notes;
+}
+function deleteNote(title) {
+    const db = getDb();
+    const result = db.prepare('DELETE FROM notes WHERE title = ?').run(title);
+    return result.changes > 0;
+}
+export const notesTool = {
+    definition: {
+        name: 'notes',
+        description: 'Save, retrieve, list, or delete personal notes.',
+        parameters: {
+            type: 'object',
+            properties: {
+                action: { type: 'string', description: 'save | get | list | delete', enum: ['save', 'get', 'list', 'delete'] },
+                title: { type: 'string', description: 'Note title' },
+                content: { type: 'string', description: 'Content (for save)' },
+                tags: { type: 'string', description: 'Tags, comma-separated' },
+            },
+            required: ['action'],
+        },
+    },
+    async execute(args) {
+        const a = args;
+        const action = String(a['action'] ?? '').trim();
+        switch (action) {
+            case 'save': {
+                const title = String(a['title'] ?? '').trim();
+                const content = String(a['content'] ?? '').trim();
+                if (!title)
+                    return { success: false, data: null, error: 'title required for save' };
+                const tags = a['tags'] ? String(a['tags']).split(',').map(t => t.trim()).filter(Boolean) : [];
+                const note = saveNote(title, content, tags);
+                return { success: true, data: note };
+            }
+            case 'get': {
+                const title = String(a['title'] ?? '').trim();
+                if (!title)
+                    return { success: false, data: null, error: 'title required for get' };
+                const note = getNote(title);
+                if (!note)
+                    return { success: false, data: null, error: `Note "${title}" not found` };
+                return { success: true, data: note };
+            }
+            case 'list': {
+                const tag = a['tags'] ? String(a['tags']).trim() : undefined;
+                const notes = listNotes(tag);
+                return { success: true, data: notes };
+            }
+            case 'delete': {
+                const title = String(a['title'] ?? '').trim();
+                if (!title)
+                    return { success: false, data: null, error: 'title required for delete' };
+                const deleted = deleteNote(title);
+                return { success: true, data: { deleted, title } };
+            }
+            default:
+                return { success: false, data: null, error: `Unknown action: ${action}` };
+        }
+    },
+};

package/dist/tools/parser.js

@@ -0,0 +1,119 @@
+// MIT License — personal-ai
+let _idCounter = 0;
+function genId() {
+    return `tc_${Date.now()}_${_idCounter++}`;
+}
+/** Strategy 1: Ollama native JSON tool_calls array */
+function parseNativeJson(text) {
+    try {
+        const parsed = JSON.parse(text.trim());
+        if (!Array.isArray(parsed))
+            return null;
+        const calls = [];
+        for (const item of parsed) {
+            if (typeof item === 'object' && item !== null && 'name' in item) {
+                const obj = item;
+                calls.push({
+                    id: genId(),
+                    name: String(obj['name'] ?? ''),
+                    arguments: (obj['arguments'] ?? obj['parameters'] ?? {}),
+                });
+            }
+        }
+        return calls.length > 0 ? calls : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Strategy 2: Gemma3 two-tag XML  <tool>name</tool><args>{}</args> */
+function parseGemmaXml(text) {
+    const toolPattern = /<tool>([\s\S]*?)<\/tool>/g;
+    const argsPattern = /<args>([\s\S]*?)<\/args>/g;
+    const toolMatches = [...text.matchAll(toolPattern)];
+    const argsMatches = [...text.matchAll(argsPattern)];
+    if (toolMatches.length === 0)
+        return null;
+    const calls = [];
+    for (let i = 0; i < toolMatches.length; i++) {
+        const name = toolMatches[i][1].trim();
+        let args = {};
+        if (argsMatches[i]) {
+            try {
+                args = JSON.parse(argsMatches[i][1].trim());
+            }
+            catch {
+                args = {};
+            }
+        }
+        calls.push({ id: genId(), name, arguments: args });
+    }
+    return calls;
+}
+/** Strategy 3: JSON code block  ```json\n{"name":...,"arguments":...}\n``` */
+function parseJsonBlock(text) {
+    const blockPattern = /```(?:json)?\s*\n([\s\S]*?)\n```/g;
+    const calls = [];
+    for (const match of text.matchAll(blockPattern)) {
+        try {
+            const parsed = JSON.parse(match[1].trim());
+            if (typeof parsed === 'object' && parsed !== null && 'name' in parsed) {
+                const obj = parsed;
+                calls.push({
+                    id: genId(),
+                    name: String(obj['name'] ?? ''),
+                    arguments: (obj['arguments'] ?? obj['parameters'] ?? {}),
+                });
+            }
+        }
+        catch {
+            // not a tool call block
+        }
+    }
+    return calls.length > 0 ? calls : null;
+}
+/**
+ * Strategy 4: named-tool XML — what some models (Gemini) emit as plain text:
+ *   <web_search><query>x</query><count>1</count></web_search>
+ *   <memory><action>save</action><content>…</content></memory>
+ * Also tolerates the malformed close `</args>` instead of `</tool_name>`.
+ * Callers MUST filter results against the tool registry — this pattern is
+ * generic enough to false-positive on arbitrary XML-ish text.
+ */
+function parseNamedToolXml(text) {
+    const outer = /<([a-z][\w]*)>([\s\S]*?)(<\/\1>|<\/args>)/gi;
+    const calls = [];
+    for (const match of text.matchAll(outer)) {
+        const name = match[1].toLowerCase();
+        const inner = match[2];
+        if (name === 'tool' || name === 'args')
+            continue; // strategy-2 territory
+        const args = {};
+        const child = /<(\w+)>([\s\S]*?)<\/\1>/g;
+        let hasChildren = false;
+        for (const c of inner.matchAll(child)) {
+            hasChildren = true;
+            const raw = c[2].trim();
+            const num = Number(raw);
+            args[c[1]] = raw !== '' && !Number.isNaN(num) ? num : raw;
+        }
+        if (!hasChildren)
+            continue; // <b>bold</b> etc. — not a tool call
+        calls.push({ id: genId(), name, arguments: args });
+    }
+    return calls.length > 0 ? calls : null;
+}
+/**
+ * Parse tool calls from model output using 4 strategies in priority order:
+ * 1. Native JSON array (Ollama tool_calls)
+ * 2. Gemma3 two-tag XML
+ * 3. JSON code block
+ * 4. Named-tool XML (Gemini-style text leakage) — filter against registry!
+ */
+export function parseToolCalls(text) {
+    return (parseNativeJson(text) ??
+        parseGemmaXml(text) ??
+        parseJsonBlock(text) ??
+        parseNamedToolXml(text) ??
+        []);
+}

package/dist/tools/registry.js

@@ -0,0 +1,88 @@
+// MIT License — personal-ai
+import { eventBus } from '../core/events.js';
+export class ToolRegistry {
+    tools = new Map();
+    confirmHandler;
+    /**
+     * Install a confirmation handler for tools marked requiresConfirmation.
+     * Without a handler such tools run unconfirmed (legacy behavior) — the CLI
+     * installs an interactive y/n prompt at startup.
+     */
+    setConfirmHandler(handler) {
+        this.confirmHandler = handler;
+    }
+    /** Register a tool. Overwrites if same name. */
+    register(tool) {
+        this.tools.set(tool.definition.name, tool);
+    }
+    /** Returns true if tool exists. */
+    has(name) {
+        return this.tools.has(name);
+    }
+    /** Total registered tool count. */
+    count() {
+        return this.tools.size;
+    }
+    /** All registered tools. */
+    getAll() {
+        return [...this.tools.values()];
+    }
+    /**
+     * Execute a tool by name. Never throws — returns error ToolResult on failure.
+     * Emits tool_called and tool_result events with timing.
+     */
+    async dispatch(name, args) {
+        const tool = this.tools.get(name);
+        const start = Date.now();
+        if (!name) {
+            return { success: false, data: null, error: 'Tool name was empty — model sent malformed tool call' };
+        }
+        if (!tool) {
+            const result = { success: false, data: null, error: `Unknown tool: ${name}` };
+            return result;
+        }
+        if (tool.requiresConfirmation && this.confirmHandler) {
+            const approved = await this.confirmHandler(name, args);
+            if (!approved) {
+                eventBus.emit('tool_called', { name, args, durationMs: 0 });
+                eventBus.emit('tool_result', { name, success: false, resultSize: 0 });
+                return { success: false, data: null, error: `User denied ${name} call` };
+            }
+        }
+        try {
+            const result = await tool.execute(args);
+            const durationMs = Date.now() - start;
+            eventBus.emit('tool_called', { name, args, durationMs });
+            eventBus.emit('tool_result', { name, success: result.success, resultSize: JSON.stringify(result.data).length });
+            return result;
+        }
+        catch (err) {
+            const durationMs = Date.now() - start;
+            const error = err instanceof Error ? err.message : String(err);
+            const result = { success: false, data: null, error };
+            eventBus.emit('tool_called', { name, args, durationMs });
+            eventBus.emit('tool_result', { name, success: false, resultSize: 0 });
+            return result;
+        }
+    }
+    /** Format tools as OpenAI-compatible native tool definitions. */
+    formatNative() {
+        return this.getAll().map(t => t.definition);
+    }
+    /** Format tools as XML instructions for Gemma3 / XML-fallback models. */
+    formatForPrompt() {
+        if (this.tools.size === 0)
+            return '';
+        const lines = ['Available tools (respond with <tool>name</tool><args>{...}</args>):'];
+        for (const tool of this.tools.values()) {
+            const { name, description, parameters } = tool.definition;
+            const params = Object.entries(parameters.properties)
+                .map(([k, v]) => `  ${k} (${v.type}): ${v.description ?? ''}`)
+                .join('\n');
+            lines.push(`\n${name}: ${description}\nParameters:\n${params}`);
+        }
+        return lines.join('\n');
+    }
+}
+/** Singleton registry shared across the application. */
+export const toolRegistry = new ToolRegistry();

package/dist/tools/tasks.js

@@ -0,0 +1,134 @@
+// MIT License — personal-ai
+import Database from 'better-sqlite3';
+import { randomUUID as uuidv4 } from 'node:crypto';
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+const DB_DIR = path.join(os.homedir(), '.personal-ai');
+const DB_PATH = path.join(DB_DIR, 'tasks.db');
+function rowToTask(row) {
+    return {
+        id: row.id,
+        title: row.title,
+        description: row.description,
+        status: row.status,
+        priority: row.priority,
+        due_date: row.due_date,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+}
+function getDb() {
+    fs.mkdirSync(DB_DIR, { recursive: true });
+    const db = new Database(DB_PATH);
+    db.pragma('journal_mode = WAL');
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      description TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'pending',
+      priority TEXT NOT NULL DEFAULT 'medium',
+      due_date TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+    CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority);
+  `);
+    return db;
+}
+export const tasksTool = {
+    definition: {
+        name: 'tasks',
+        description: 'Manage tasks: create, update, list.',
+        parameters: {
+            type: 'object',
+            properties: {
+                action: { type: 'string', description: 'create | update | list | get | delete', enum: ['create', 'update', 'list', 'get', 'delete'] },
+                id: { type: 'string', description: 'Task ID (for update/get/delete)' },
+                title: { type: 'string', description: 'Task title' },
+                description: { type: 'string', description: 'Task description' },
+                status: { type: 'string', description: 'pending | in_progress | done', enum: ['pending', 'in_progress', 'done'] },
+                priority: { type: 'string', description: 'low | medium | high', enum: ['low', 'medium', 'high'] },
+                due_date: { type: 'string', description: 'Due date ISO string' },
+                filter: { type: 'string', description: 'Filter: pending|in_progress|done|all' },
+            },
+            required: ['action'],
+        },
+    },
+    async execute(args) {
+        const a = args;
+        const action = String(a['action'] ?? '').trim();
+        const db = getDb();
+        const now = new Date().toISOString();
+        switch (action) {
+            case 'create': {
+                const title = String(a['title'] ?? '').trim();
+                if (!title)
+                    return { success: false, data: null, error: 'title required' };
+                const task = {
+                    id: uuidv4(),
+                    title,
+                    description: String(a['description'] ?? ''),
+                    status: 'pending',
+                    priority: a['priority'] ?? 'medium',
+                    due_date: a['due_date'] ? String(a['due_date']) : null,
+                    created_at: now,
+                    updated_at: now,
+                };
+                db.prepare('INSERT INTO tasks (id,title,description,status,priority,due_date,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?)')
+                    .run(task.id, task.title, task.description, task.status, task.priority, task.due_date, task.created_at, task.updated_at);
+                return { success: true, data: task };
+            }
+            case 'update': {
+                const id = String(a['id'] ?? '').trim();
+                if (!id)
+                    return { success: false, data: null, error: 'id required for update' };
+                const existing = db.prepare('SELECT * FROM tasks WHERE id = ?').get(id);
+                if (!existing)
+                    return { success: false, data: null, error: `Task ${id} not found` };
+                const updates = { updated_at: now };
+                if (a['title'])
+                    updates.title = String(a['title']);
+                if (a['description'])
+                    updates.description = String(a['description']);
+                if (a['status'])
+                    updates.status = String(a['status']);
+                if (a['priority'])
+                    updates.priority = String(a['priority']);
+                if (a['due_date'])
+                    updates.due_date = String(a['due_date']);
+                const merged = { ...existing, ...updates };
+                db.prepare('UPDATE tasks SET title=?,description=?,status=?,priority=?,due_date=?,updated_at=? WHERE id=?')
+                    .run(merged.title, merged.description, merged.status, merged.priority, merged.due_date, merged.updated_at, id);
+                return { success: true, data: rowToTask(merged) };
+            }
+            case 'list': {
+                const filter = String(a['filter'] ?? 'all');
+                const rows = filter === 'all'
+                    ? db.prepare('SELECT * FROM tasks ORDER BY priority DESC, created_at DESC').all()
+                    : db.prepare('SELECT * FROM tasks WHERE status = ? ORDER BY created_at DESC').all(filter);
+                return { success: true, data: rows.map(rowToTask) };
+            }
+            case 'get': {
+                const id = String(a['id'] ?? '').trim();
+                if (!id)
+                    return { success: false, data: null, error: 'id required' };
+                const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(id);
+                if (!row)
+                    return { success: false, data: null, error: `Task ${id} not found` };
+                return { success: true, data: rowToTask(row) };
+            }
+            case 'delete': {
+                const id = String(a['id'] ?? '').trim();
+                if (!id)
+                    return { success: false, data: null, error: 'id required' };
+                const result = db.prepare('DELETE FROM tasks WHERE id = ?').run(id);
+                return { success: true, data: { deleted: result.changes > 0, id } };
+            }
+            default:
+                return { success: false, data: null, error: `Unknown action: ${action}` };
+        }
+    },
+};

package/dist/tools/types.js

@@ -0,0 +1,3 @@
+// MIT License — personal-ai
+// fallow-ignore-file unused-files
+export {};

package/dist/tools/web-search.js

@@ -0,0 +1,108 @@
+// MIT License — personal-ai
+const SERPER_ENDPOINT = 'https://google.serper.dev/search';
+const BRAVE_ENDPOINT = 'https://api.search.brave.com/res/v1/web/search';
+const DDG_ENDPOINT = 'https://api.duckduckgo.com/';
+async function searchSerper(query, count) {
+    const key = process.env['SERPER_API_KEY'];
+    if (!key)
+        throw new Error('SERPER_API_KEY not set');
+    const res = await fetch(SERPER_ENDPOINT, {
+        method: 'POST',
+        headers: { 'X-API-KEY': key, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ q: query, num: count }),
+    });
+    if (!res.ok)
+        throw new Error(`Serper HTTP ${res.status}`);
+    const data = await res.json();
+    const results = (data.organic ?? []).slice(0, count).map(r => ({
+        title: r.title,
+        url: r.link,
+        snippet: r.snippet ?? '',
+    }));
+    // Prepend answerBox/knowledgeGraph as a top result if present
+    const direct = data.answerBox?.answer ?? data.answerBox?.snippet ?? data.knowledgeGraph?.description;
+    if (direct) {
+        results.unshift({
+            title: data.answerBox?.title ?? data.knowledgeGraph?.title ?? 'Direct Answer',
+            url: '',
+            snippet: direct,
+        });
+    }
+    return results;
+}
+async function searchBrave(query, count) {
+    const key = process.env['BRAVE_SEARCH_API_KEY'];
+    if (!key)
+        throw new Error('BRAVE_SEARCH_API_KEY not set');
+    const url = `${BRAVE_ENDPOINT}?q=${encodeURIComponent(query)}&count=${count}`;
+    const res = await fetch(url, {
+        headers: { 'Accept': 'application/json', 'X-Subscription-Token': key },
+    });
+    if (!res.ok)
+        throw new Error(`Brave HTTP ${res.status}`);
+    const data = await res.json();
+    return (data.web?.results ?? []).map(r => ({ title: r.title, url: r.url, snippet: r.description ?? '' }));
+}
+async function searchDdg(query, count) {
+    const url = `${DDG_ENDPOINT}?q=${encodeURIComponent(query)}&format=json&no_html=1&skip_disambig=1`;
+    const res = await fetch(url, { headers: { 'Accept': 'application/json' } });
+    if (!res.ok)
+        throw new Error(`DDG HTTP ${res.status}`);
+    const data = await res.json();
+    const results = (data.RelatedTopics ?? [])
+        .filter((t) => typeof t.Text === 'string' && typeof t.FirstURL === 'string')
+        .slice(0, count)
+        .map(t => ({ title: t.Text.split(' - ')[0] ?? t.Text, url: t.FirstURL, snippet: t.Text }));
+    if (results.length === 0)
+        throw new Error('DDG returned no results');
+    return results;
+}
+// ── Orchestrator ─────────────────────────────────────────────────────────────
+/** Priority: Serper → Brave → DDG. Returns up to `count` results. */
+export async function webSearch(query, count = 5) {
+    const noSerper = !process.env['SERPER_API_KEY'];
+    const noBrave = !process.env['BRAVE_SEARCH_API_KEY'];
+    const engines = [];
+    if (!noSerper)
+        engines.push({ name: 'serper', fn: () => searchSerper(query, count) });
+    if (!noBrave)
+        engines.push({ name: 'brave', fn: () => searchBrave(query, count) });
+    engines.push({ name: 'duckduckgo', fn: () => searchDdg(query, count) });
+    let lastErr = '';
+    for (const engine of engines) {
+        try {
+            const results = await engine.fn();
+            return { success: true, data: { query, source: engine.name, results } };
+        }
+        catch (err) {
+            lastErr = String(err);
+        }
+    }
+    // All engines failed
+    const hint = (noSerper && noBrave)
+        ? 'No search API key configured. Add SERPER_API_KEY to .env — free at https://serper.dev (2500 searches, no card needed).'
+        : `All search engines failed: ${lastErr}`;
+    return { success: false, data: null, error: hint };
+}
+export const webSearchTool = {
+    definition: {
+        name: 'web_search',
+        description: 'Search web for current/live information.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+                count: { type: 'number', description: 'Results count, max 10' },
+            },
+            required: ['query'],
+        },
+    },
+    async execute(args) {
+        const a = args;
+        const query = String(a['query'] ?? '').trim();
+        if (!query)
+            return { success: false, data: null, error: 'query is required' };
+        const count = Math.min(Number(a['count'] ?? 5), 10);
+        return webSearch(query, count);
+    },
+};