listener-ai 1.7.0 → 2.0.0

package/dist/agentService.js

@@ -0,0 +1,391 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentService = exports.READABLE_CONFIG_KEYS = exports.WRITABLE_CONFIG_KEYS = void 0;
+exports.coerceConfigValue = coerceConfigValue;
+exports.isValidFolderName = isValidFolderName;
+exports.describeProposal = describeProposal;
+const genai_1 = require("@google/genai");
+const path = __importStar(require("path"));
+const searchService_1 = require("./searchService");
+const outputService_1 = require("./outputService");
+exports.WRITABLE_CONFIG_KEYS = [
+    'autoMode',
+    'meetingDetection',
+    'displayDetection',
+    'globalShortcut',
+    'maxRecordingMinutes',
+    'recordingReminderMinutes',
+    'minRecordingSeconds',
+];
+exports.READABLE_CONFIG_KEYS = [
+    ...exports.WRITABLE_CONFIG_KEYS,
+    'geminiModel',
+    'geminiFlashModel',
+];
+function isWritableKey(key) {
+    return exports.WRITABLE_CONFIG_KEYS.includes(key);
+}
+function isReadableKey(key) {
+    return exports.READABLE_CONFIG_KEYS.includes(key);
+}
+/** Coerce agent-supplied value to the right type per key. */
+function coerceConfigValue(key, raw) {
+    switch (key) {
+        case 'autoMode':
+        case 'meetingDetection':
+        case 'displayDetection': {
+            if (typeof raw === 'boolean')
+                return { ok: true, value: raw };
+            if (raw === 'true')
+                return { ok: true, value: true };
+            if (raw === 'false')
+                return { ok: true, value: false };
+            return { ok: false, error: `${key} expects a boolean` };
+        }
+        case 'globalShortcut': {
+            if (typeof raw !== 'string' || raw.trim() === '') {
+                return { ok: false, error: `${key} expects a non-empty string` };
+            }
+            return { ok: true, value: raw.trim() };
+        }
+        case 'maxRecordingMinutes':
+        case 'recordingReminderMinutes':
+        case 'minRecordingSeconds': {
+            const n = typeof raw === 'number' ? raw : parseInt(String(raw), 10);
+            if (!Number.isFinite(n) || n < 0) {
+                return { ok: false, error: `${key} expects a non-negative integer` };
+            }
+            return { ok: true, value: Math.floor(n) };
+        }
+    }
+}
+function buildTools(scope, hasConfirm) {
+    const tools = [];
+    if (scope.kind === 'all') {
+        tools.push({
+            name: 'search_transcriptions',
+            description: 'Full-text search across saved meeting transcriptions. Returns top-k hits with title, date, snippet, and folder name. Use this to find meetings relevant to the user question.',
+            parameters: {
+                type: genai_1.Type.OBJECT,
+                properties: {
+                    query: { type: genai_1.Type.STRING, description: 'Search keywords. Can be Korean or English.' },
+                    limit: { type: genai_1.Type.INTEGER, description: 'Max hits to return (default 5).' },
+                    include_transcript: { type: genai_1.Type.BOOLEAN, description: 'Also search the full transcript body (slower). Default false.' },
+                },
+                required: ['query'],
+            },
+        });
+        tools.push({
+            name: 'list_recent_transcriptions',
+            description: 'List the most recent saved transcriptions, newest first. Use when the user asks "what did we talk about recently" or "show me yesterday\'s meetings".',
+            parameters: {
+                type: genai_1.Type.OBJECT,
+                properties: {
+                    limit: { type: genai_1.Type.INTEGER, description: 'Max entries (default 10).' },
+                },
+            },
+        });
+        tools.push({
+            name: 'get_transcription',
+            description: 'Fetch a saved meeting record (summary, key points, action items) by folder name. Pass include_transcript=true only when you need the verbatim transcript body; omit it for summary-level questions to keep the response compact.',
+            parameters: {
+                type: genai_1.Type.OBJECT,
+                properties: {
+                    folder_name: { type: genai_1.Type.STRING, description: 'The folderName returned by search_transcriptions or list_recent_transcriptions.' },
+                    include_transcript: { type: genai_1.Type.BOOLEAN, description: 'Include the full transcript body. Default false.' },
+                },
+                required: ['folder_name'],
+            },
+        });
+    }
+    tools.push({
+        name: 'get_config',
+        description: 'Read a single Listener.AI setting value. Allowed keys: ' + exports.READABLE_CONFIG_KEYS.join(', ') + '. API keys and database IDs are never readable here.',
+        parameters: {
+            type: genai_1.Type.OBJECT,
+            properties: {
+                key: { type: genai_1.Type.STRING, description: 'One of: ' + exports.READABLE_CONFIG_KEYS.join(', ') },
+            },
+            required: ['key'],
+        },
+    });
+    if (hasConfirm) {
+        tools.push({
+            name: 'set_config',
+            description: 'Propose a change to a Listener.AI setting. Requires user confirmation before taking effect. Allowed keys: ' + exports.WRITABLE_CONFIG_KEYS.join(', ') + '. Do NOT try to set API keys, Notion database ID, or other credentials here.',
+            parameters: {
+                type: genai_1.Type.OBJECT,
+                properties: {
+                    key: { type: genai_1.Type.STRING, description: 'One of: ' + exports.WRITABLE_CONFIG_KEYS.join(', ') },
+                    value: { type: genai_1.Type.STRING, description: 'The new value. For booleans pass "true"/"false"; for numbers pass the digits as a string; for strings pass the string.' },
+                    reason: { type: genai_1.Type.STRING, description: 'Short human-readable reason shown to the user in the confirmation prompt.' },
+                },
+                required: ['key', 'value'],
+            },
+        });
+    }
+    return tools;
+}
+function systemInstructionFor(scope, currentTranscriptionTitle) {
+    const common = `You are the assistant inside Listener.AI, a Korean-first meeting recorder. Answer concisely in the user's language (default to Korean if the question is in Korean). Ground factual claims in tool results — never invent meeting content. If the user asks for something outside your tools (e.g. sending email, starting a recording), politely say you can't do that yet.`;
+    if (scope.kind === 'single') {
+        return `${common}\n\nYou are currently focused on a single meeting titled "${currentTranscriptionTitle ?? 'this meeting'}". The full transcription data is already provided in the conversation. Prefer answering directly from that data. Do not call search_transcriptions or list_recent_transcriptions in this mode — they are disabled. You may still read or change app settings via get_config / set_config (set_config always requires user confirmation).`;
+    }
+    return `${common}\n\nScope: ALL saved meetings. Use search_transcriptions to find relevant meetings (title/summary/key points are searched by default; pass include_transcript=true if keywords are likely only in the transcript body). Use list_recent_transcriptions for "recent/latest" questions. Use get_transcription to read a specific meeting when you have its folder name.`;
+}
+/** Reject folder names that could escape the transcriptions directory. A valid
+ *  entry produced by `saveTranscription` never contains path separators, so we
+ *  can keep the guard simple without duplicating the sanitizer. */
+function isValidFolderName(name) {
+    if (typeof name !== 'string' || name === '' || name === '.' || name === '..')
+        return false;
+    if (name.includes('/') || name.includes('\\') || name.includes('\0'))
+        return false;
+    if (name.startsWith('.'))
+        return false;
+    return true;
+}
+function buildSinglePrimer(data) {
+    const lines = [];
+    lines.push(`[Context: meeting "${data.title}"${data.transcribedAt ? ` recorded ${data.transcribedAt.slice(0, 10)}` : ''}]`);
+    if (data.summary)
+        lines.push(`Summary: ${data.summary}`);
+    if (data.keyPoints?.length) {
+        lines.push('Key points:');
+        for (const p of data.keyPoints)
+            lines.push(`- ${p}`);
+    }
+    if (data.actionItems?.length) {
+        lines.push('Action items:');
+        for (const a of data.actionItems)
+            lines.push(`- ${a}`);
+    }
+    if (data.transcript) {
+        lines.push('Transcript:');
+        lines.push(data.transcript);
+    }
+    return lines.join('\n');
+}
+function historyToContents(history) {
+    const out = [];
+    for (const m of history) {
+        // Model messages replay their full turn cluster (text + function calls +
+        // tool responses) so the agent can reason about prior tool use.
+        if (m.role === 'model' && m.turns && m.turns.length > 0) {
+            out.push(...m.turns);
+            continue;
+        }
+        out.push({ role: m.role, parts: [{ text: m.text }] });
+    }
+    return out;
+}
+function extractFinalText(parts) {
+    if (!parts)
+        return '';
+    return parts
+        .map((p) => (typeof p.text === 'string' ? p.text : ''))
+        .filter(Boolean)
+        .join('\n')
+        .trim();
+}
+class AgentService {
+    constructor(opts) {
+        this.ai = new genai_1.GoogleGenAI({ apiKey: opts.apiKey });
+        this.dataPath = opts.dataPath;
+        this.configService = opts.configService;
+        this.defaultModel = opts.defaultModel ?? opts.configService.getGeminiFlashModel();
+    }
+    async run(opts) {
+        const model = opts.model ?? this.defaultModel;
+        const maxSteps = opts.maxSteps ?? 6;
+        const tools = buildTools(opts.scope, !!opts.confirm);
+        // Load the single-meeting record once if needed; title + primer derive from it.
+        const singleData = opts.scope.kind === 'single' && isValidFolderName(opts.scope.folderName)
+            ? (0, outputService_1.readTranscription)(path.join((0, outputService_1.getTranscriptionsDir)(this.dataPath), opts.scope.folderName))
+            : null;
+        const systemInstruction = systemInstructionFor(opts.scope, singleData?.title);
+        const history = opts.history ? [...opts.history] : [];
+        // For single-meeting scope the primer must precede all prior turns so the
+        // model sees the meeting context before its own earlier responses about it.
+        const contents = [];
+        if (singleData) {
+            contents.push({ role: 'user', parts: [{ text: buildSinglePrimer(singleData) }] });
+        }
+        for (const c of historyToContents(history))
+            contents.push(c);
+        contents.push({ role: 'user', parts: [{ text: opts.question }] });
+        history.push({ role: 'user', text: opts.question });
+        // Track turns added from here on so they can be attached to the model
+        // message for multi-turn tool memory.
+        const modelTurnsStart = contents.length;
+        const applied = [];
+        let finalAnswer = '';
+        for (let step = 0; step < maxSteps; step++) {
+            const response = await this.ai.models.generateContent({
+                model,
+                contents,
+                config: {
+                    systemInstruction,
+                    temperature: 0.3,
+                    tools: tools.length > 0 ? [{ functionDeclarations: tools }] : undefined,
+                },
+            });
+            const candidate = response.candidates?.[0];
+            const parts = candidate?.content?.parts ?? [];
+            const functionCalls = response.functionCalls ?? [];
+            // Record model turn verbatim (keeps function call history correct).
+            if (candidate?.content) {
+                contents.push(candidate.content);
+            }
+            if (functionCalls.length === 0) {
+                finalAnswer = extractFinalText(parts);
+                break;
+            }
+            // Dispatch all tool calls from this turn in parallel. Read-only tools
+            // (search/list/get) benefit directly; set_config awaits a user click but
+            // that still happens concurrently with the reads rather than after them.
+            const results = await Promise.all(functionCalls.map((call) => this.dispatchTool(call, opts, applied)));
+            const toolResponseParts = functionCalls.map((call, i) => ({
+                functionResponse: {
+                    id: call.id,
+                    name: call.name ?? '',
+                    response: results[i],
+                },
+            }));
+            contents.push({ role: 'user', parts: toolResponseParts });
+        }
+        if (!finalAnswer) {
+            finalAnswer = '(no answer produced within step limit)';
+        }
+        const modelTurns = contents.slice(modelTurnsStart);
+        history.push({ role: 'model', text: finalAnswer, turns: modelTurns });
+        return { answer: finalAnswer, appliedActions: applied, history };
+    }
+    async dispatchTool(call, opts, applied) {
+        const args = (call.args ?? {});
+        try {
+            switch (call.name) {
+                case 'search_transcriptions': {
+                    const query = typeof args.query === 'string' ? args.query : '';
+                    if (!query.trim())
+                        return { error: 'query is required' };
+                    const limit = typeof args.limit === 'number' ? args.limit : 5;
+                    const includeTranscript = args.include_transcript === true;
+                    const fields = includeTranscript ? [...searchService_1.ALL_FIELDS] : ['title', 'summary', 'keyPoints', 'actionItems'];
+                    const hits = (0, searchService_1.searchTranscriptions)(this.dataPath, { query, fields, limit });
+                    return {
+                        hits: hits.map((h) => ({
+                            folder_name: h.entry.folderName,
+                            title: h.data.title,
+                            transcribed_at: h.entry.transcribedAt,
+                            matched_fields: h.matchedFields,
+                            snippet: h.snippet,
+                            summary: h.data.summary,
+                        })),
+                    };
+                }
+                case 'list_recent_transcriptions': {
+                    const limit = typeof args.limit === 'number' ? args.limit : 10;
+                    const entries = (0, outputService_1.listTranscriptions)(this.dataPath, limit);
+                    return {
+                        entries: entries.map((e) => ({
+                            folder_name: e.folderName,
+                            title: e.title,
+                            transcribed_at: e.transcribedAt,
+                        })),
+                    };
+                }
+                case 'get_transcription': {
+                    const folderName = typeof args.folder_name === 'string' ? args.folder_name : '';
+                    if (!isValidFolderName(folderName))
+                        return { error: 'folder_name must be a bare folder name returned by search/list (no slashes, no ..)' };
+                    const folderPath = path.join((0, outputService_1.getTranscriptionsDir)(this.dataPath), folderName);
+                    const data = (0, outputService_1.readTranscription)(folderPath);
+                    if (!data)
+                        return { error: `transcription not found: ${folderName}` };
+                    const result = {
+                        title: data.title,
+                        transcribed_at: data.transcribedAt,
+                        summary: data.summary,
+                        key_points: data.keyPoints ?? [],
+                        action_items: data.actionItems ?? [],
+                    };
+                    if (args.include_transcript === true)
+                        result.transcript = data.transcript;
+                    return result;
+                }
+                case 'get_config': {
+                    const key = typeof args.key === 'string' ? args.key : '';
+                    if (!isReadableKey(key))
+                        return { error: `unknown or non-readable key: ${key}` };
+                    const value = this.configService.getAllConfig()[key];
+                    return { key, value: value ?? null };
+                }
+                case 'set_config': {
+                    if (!opts.confirm)
+                        return { error: 'set_config not available in this session' };
+                    const key = typeof args.key === 'string' ? args.key : '';
+                    if (!isWritableKey(key))
+                        return { error: `key is not settable via agent: ${key}` };
+                    const coerced = coerceConfigValue(key, args.value);
+                    if (!coerced.ok)
+                        return { error: coerced.error };
+                    const previousValue = this.configService.getAllConfig()[key];
+                    const description = describeProposal(key, coerced.value, previousValue, typeof args.reason === 'string' ? args.reason : undefined);
+                    const approved = await opts.confirm({ kind: 'setConfig', key, value: coerced.value, currentValue: previousValue, description });
+                    if (!approved) {
+                        return { approved: false, note: 'User declined the change.' };
+                    }
+                    this.configService.updateConfig({ [key]: coerced.value });
+                    applied.push({ type: 'setConfig', key, value: coerced.value, previousValue });
+                    return { approved: true, key, value: coerced.value };
+                }
+                default:
+                    return { error: `unknown tool: ${call.name}` };
+            }
+        }
+        catch (err) {
+            return { error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+}
+exports.AgentService = AgentService;
+function describeProposal(key, value, current, reason) {
+    const currentStr = current === undefined || current === null || current === '' ? '(unset)' : JSON.stringify(current);
+    const valueStr = JSON.stringify(value);
+    const base = `Change ${key}: ${currentStr} -> ${valueStr}`;
+    return reason ? `${base} (${reason})` : base;
+}

package/dist/cli.js

@@ -40,6 +40,8 @@ const dataPath_1 = require("./dataPath");
 const configService_1 = require("./configService");
 const geminiService_1 = require("./geminiService");
 const outputService_1 = require("./outputService");
+const searchService_1 = require("./searchService");
+const agentService_1 = require("./agentService");
 const SUPPORTED_EXTENSIONS = new Set([
     '.mp3', '.m4a', '.wav', '.ogg', '.flac', '.aac', '.wma', '.opus', '.webm',
 ]);
@@ -49,6 +51,10 @@ function usage() {
         '       listener show <ref>                 Print summary to stdout\n' +
         '       listener export <ref> [<path>] [--json] [--transcript]\n' +
         '                                           Export transcription\n' +
+        '       listener search <query> [--limit <n>] [--transcript] [--field <name>]\n' +
+        '                                           Search past transcriptions\n' +
+        '       listener ask <question> [--ref <ref>]\n' +
+        '                                           Ask the AI agent about saved meetings or settings\n' +
         '       listener config list|get|set|path   Manage configuration\n' +
         '\n' +
         '<ref> is a number from `listener list` or a folder name.\n' +
@@ -57,7 +63,8 @@ function usage() {
         '  --output <dir>   Parent directory for the output folder\n' +
         '  --limit <n>      Max results (0 = all, default: 20)\n' +
         '  --json           Export as JSON instead of markdown\n' +
-        '  --transcript     Include full transcript in export output\n' +
+        '  --transcript     Include transcript body (export: append; search: widen scope)\n' +
+        '  --field <name>   Restrict search to one of: title, summary, keyPoints, actionItems, transcript, all\n' +
         '  --help           Show this help message\n');
     process.exit(1);
 }
@@ -303,6 +310,134 @@ function handleExport(args) {
         }
     }
 }
+function handleSearch(args) {
+    const VALID_FIELDS = [...searchService_1.ALL_FIELDS, 'all'];
+    let query;
+    let limit = 20;
+    let includeTranscript = false;
+    let field;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--limit' && i + 1 < args.length) {
+            const n = parseInt(args[++i], 10);
+            if (isNaN(n) || n < 0) {
+                process.stderr.write('Error: --limit must be a non-negative integer\n');
+                process.exit(1);
+            }
+            limit = n;
+            continue;
+        }
+        if (a === '--transcript') {
+            includeTranscript = true;
+            continue;
+        }
+        if (a === '--field' && i + 1 < args.length) {
+            const v = args[++i];
+            if (!VALID_FIELDS.includes(v)) {
+                process.stderr.write(`Error: --field must be one of: ${VALID_FIELDS.join(', ')}\n`);
+                process.exit(1);
+            }
+            field = v;
+            continue;
+        }
+        if (a.startsWith('-')) {
+            process.stderr.write(`Error: Unknown option: ${a}\n`);
+            process.exit(1);
+        }
+        if (!query) {
+            query = a;
+            continue;
+        }
+        process.stderr.write(`Error: Unexpected argument: ${a} (quote multi-word queries)\n`);
+        process.exit(1);
+    }
+    if (!query || query.trim() === '') {
+        process.stderr.write('Error: Missing query. Usage: listener search <query> [--limit <n>] [--transcript] [--field <name>]\n');
+        process.exit(1);
+    }
+    const dataPath = (0, dataPath_1.getDataPath)();
+    const fields = (0, searchService_1.resolveFields)({ field, includeTranscript });
+    const hits = (0, searchService_1.searchTranscriptions)(dataPath, { query, fields, limit });
+    if (hits.length === 0) {
+        process.stderr.write('No results.\n');
+        return;
+    }
+    for (const hit of hits) {
+        const date = hit.entry.transcribedAt ? hit.entry.transcribedAt.slice(0, 10) : '          ';
+        const title = hit.data.title.length > 60 ? hit.data.title.slice(0, 57) + '...' : hit.data.title;
+        process.stdout.write(`${date}  ${title}\n`);
+        process.stdout.write(`  ref:     ${hit.entry.folderName}\n`);
+        process.stdout.write(`  matches: ${hit.matchedFields.join(', ')}\n`);
+        if (hit.snippet) {
+            process.stdout.write(`  ${hit.snippet}\n`);
+        }
+        process.stdout.write('\n');
+    }
+}
+async function promptYesNo(message) {
+    return new Promise((resolve) => {
+        process.stderr.write(`${message} [y/N] `);
+        const stdin = process.stdin;
+        const onData = (chunk) => {
+            stdin.off('data', onData);
+            stdin.pause();
+            const answer = chunk.toString('utf-8').trim().toLowerCase();
+            resolve(answer === 'y' || answer === 'yes');
+        };
+        stdin.resume();
+        stdin.on('data', onData);
+    });
+}
+async function handleAsk(args) {
+    let question;
+    let ref;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--ref' && i + 1 < args.length) {
+            ref = args[++i];
+            continue;
+        }
+        if (a.startsWith('-')) {
+            process.stderr.write(`Error: Unknown option: ${a}\n`);
+            process.exit(1);
+        }
+        if (!question) {
+            question = a;
+            continue;
+        }
+        process.stderr.write(`Error: Unexpected argument: ${a} (quote multi-word questions)\n`);
+        process.exit(1);
+    }
+    if (!question || question.trim() === '') {
+        process.stderr.write('Error: Missing question. Usage: listener ask <question> [--ref <ref>]\n');
+        process.exit(1);
+    }
+    const dataPath = (0, dataPath_1.getDataPath)();
+    const config = new configService_1.ConfigService(dataPath);
+    const apiKey = config.getGeminiApiKey();
+    if (!apiKey) {
+        process.stderr.write('Error: Gemini API key not found. Set GEMINI_API_KEY env var or configure via the Listener.AI app.\n');
+        process.exit(1);
+    }
+    let scope = { kind: 'all' };
+    if (ref) {
+        const folderPath = resolveRef(ref, dataPath);
+        scope = { kind: 'single', folderName: path.basename(folderPath) };
+    }
+    const agent = new agentService_1.AgentService({ apiKey, dataPath, configService: config });
+    const confirm = async (proposal) => {
+        process.stderr.write('\n');
+        return promptYesNo(`Proposed change -> ${proposal.description}\nApply?`);
+    };
+    const result = await agent.run({ question, scope, confirm });
+    process.stdout.write(`${result.answer}\n`);
+    if (result.appliedActions.length > 0) {
+        process.stderr.write('\nApplied:\n');
+        for (const action of result.appliedActions) {
+            process.stderr.write(`  ${action.key}: ${JSON.stringify(action.previousValue ?? null)} -> ${JSON.stringify(action.value)}\n`);
+        }
+    }
+}
 async function main() {
     const args = process.argv.slice(2);
     if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
@@ -324,6 +459,14 @@ async function main() {
         handleExport(args.slice(1));
         return;
     }
+    if (args[0] === 'search') {
+        handleSearch(args.slice(1));
+        return;
+    }
+    if (args[0] === 'ask') {
+        await handleAsk(args.slice(1));
+        return;
+    }
     // Parse arguments
     let filePath;
     let outputDir;

package/dist/main.js

@@ -50,6 +50,8 @@ const autoUpdaterService_1 = require("./services/autoUpdaterService");
 const notificationService_1 = require("./services/notificationService");
 const releaseNotesService_1 = require("./services/releaseNotesService");
 const outputService_1 = require("./outputService");
+const searchService_1 = require("./searchService");
+const agentService_1 = require("./agentService");
 global.isQuitting = false;
 let mainWindow = null;
 const audioRecorder = new simpleAudioRecorder_1.SimpleAudioRecorder();
@@ -62,6 +64,35 @@ const displayDetector = new displayDetectorService_1.DisplayDetectorService();
 let meetingAutoStartedRecording = false;
 let geminiService = null;
 let notionService = null;
+let agentService = null;
+function getAgentService() {
+    if (agentService)
+        return agentService;
+    const apiKey = configService.getGeminiApiKey();
+    if (!apiKey)
+        return null;
+    agentService = new agentService_1.AgentService({
+        apiKey,
+        dataPath: electron_1.app.getPath('userData'),
+        configService,
+    });
+    return agentService;
+}
+// Pending agent confirmation resolvers keyed by request id. The renderer responds
+// via the 'agent-confirm-response' IPC and we resolve the promise the agent is awaiting.
+// If the window goes away (reload, crash, close) before the user answers, we
+// auto-reject so the awaiting agent-chat call can unwind instead of hanging.
+const pendingConfirms = new Map();
+let confirmIdCounter = 0;
+function rejectAllPendingConfirms() {
+    for (const resolver of pendingConfirms.values()) {
+        try {
+            resolver(false);
+        }
+        catch { /* ignore */ }
+    }
+    pendingConfirms.clear();
+}
 let recordingMaxTimer = null;
 let recordingReminderTimer = null;
 function createGeminiService() {
@@ -177,6 +208,8 @@ function createWindow() {
     mainWindow = new electron_1.BrowserWindow({
         width: 1000,
         height: 700,
+        minWidth: 480,
+        minHeight: 520,
         webPreferences: {
             nodeIntegration: false,
             contextIsolation: true,
@@ -214,8 +247,18 @@ function createWindow() {
         }
     });
     mainWindow.on('closed', () => {
+        rejectAllPendingConfirms();
         mainWindow = null;
     });
+    // Reload or crash drops the renderer that would answer a confirm prompt;
+    // unblock any waiting agent call so it returns cleanly instead of hanging.
+    mainWindow.webContents.on('did-start-navigation', (_e, _url, isInPlace, isMainFrame) => {
+        if (isMainFrame && !isInPlace)
+            rejectAllPendingConfirms();
+    });
+    mainWindow.webContents.on('render-process-gone', () => {
+        rejectAllPendingConfirms();
+    });
 }
 electron_1.app.whenReady().then(() => {
     // Initialize auto-updater
@@ -525,30 +568,42 @@ electron_1.ipcMain.handle('stop-recording', async () => {
     }
 });
 // Configuration handlers
+// Apply runtime side effects for changed config keys (shortcut re-registration,
+// detector on/off, service re-creation). Called from both the GUI save-config
+// IPC and the agent-chat flow when set_config mutations land.
+function applyConfigSideEffects(changed) {
+    if (changed.knownWords !== undefined || changed.geminiApiKey !== undefined || changed.geminiModel !== undefined || changed.geminiFlashModel !== undefined) {
+        geminiService = createGeminiService();
+        agentService = null;
+    }
+    if (changed.globalShortcut !== undefined) {
+        registerGlobalShortcut();
+    }
+    if (changed.meetingDetection !== undefined) {
+        meetingDetector.setEnabled(changed.meetingDetection);
+    }
+    if (changed.displayDetection !== undefined) {
+        displayDetector.setEnabled(changed.displayDetection);
+    }
+    if (changed.notionApiKey !== undefined || changed.notionDatabaseId !== undefined) {
+        const apiKey = configService.getNotionApiKey();
+        const databaseId = configService.getNotionDatabaseId();
+        if (apiKey && databaseId) {
+            notionService = new notionService_1.NotionService({ apiKey, databaseId });
+        }
+    }
+}
+// Tell the renderer the config has changed out-of-band so it can re-read and
+// re-render its UI state (toggle checkboxes etc.). Used by the agent flow.
+function broadcastConfigChanged() {
+    if (mainWindow && !mainWindow.isDestroyed()) {
+        mainWindow.webContents.send('config-changed', configService.getAllConfig());
+    }
+}
 electron_1.ipcMain.handle('save-config', async (_, config) => {
     try {
         configService.updateConfig(config);
-        // Recreate GeminiService if any relevant setting changed
-        if (config.knownWords !== undefined || config.geminiApiKey !== undefined || config.geminiModel !== undefined || config.geminiFlashModel !== undefined) {
-            geminiService = createGeminiService();
-        }
-        if (config.globalShortcut !== undefined) {
-            registerGlobalShortcut();
-        }
-        if (config.meetingDetection !== undefined) {
-            meetingDetector.setEnabled(config.meetingDetection);
-        }
-        if (config.displayDetection !== undefined) {
-            displayDetector.setEnabled(config.displayDetection);
-        }
-        // Recreate Notion service if either field changed
-        if (config.notionApiKey !== undefined || config.notionDatabaseId !== undefined) {
-            const apiKey = configService.getNotionApiKey();
-            const databaseId = configService.getNotionDatabaseId();
-            if (apiKey && databaseId) {
-                notionService = new notionService_1.NotionService({ apiKey, databaseId });
-            }
-        }
+        applyConfigSideEffects(config);
         return {
             success: true,
             configPath: electron_1.app.getPath('userData')
@@ -741,11 +796,13 @@ electron_1.ipcMain.handle('get-metadata', async (_, filePath) => {
                     success: true,
                     data: {
                         ...metadata,
+                        folderName: path.basename(metadata.transcriptionPath),
                         transcript: transcription.transcript,
                         summary: transcription.summary,
                         keyPoints: transcription.keyPoints,
                         actionItems: transcription.actionItems,
                         customFields: transcription.customFields ?? metadata.customFields,
+                        emoji: transcription.emoji,
                     }
                 };
             }
@@ -777,6 +834,47 @@ electron_1.ipcMain.handle('open-recordings-folder', async () => {
     // Open the folder in the system file explorer
     electron_1.shell.openPath(recordingsPath);
 });
+// Search past transcriptions
+electron_1.ipcMain.handle('search-transcriptions', async (_, opts) => {
+    try {
+        const query = (opts?.query ?? '').trim();
+        if (!query)
+            return { success: true, hits: [] };
+        // Validate fields against the known whitelist; drop anything else. Unvalidated input
+        // (e.g. a stringified 'title') would be passed to `new Set(...)` and silently match nothing.
+        const requested = Array.isArray(opts.fields) ? opts.fields : [];
+        const filtered = requested.filter((f) => searchService_1.ALL_FIELDS.includes(f));
+        const fields = filtered.length > 0 ? filtered : searchService_1.ALL_FIELDS;
+        const limit = Number.isFinite(opts.limit) && opts.limit >= 0 ? opts.limit : 20;
+        const dataPath = electron_1.app.getPath('userData');
+        const raw = (0, searchService_1.searchTranscriptions)(dataPath, { query, fields, limit });
+        const hits = raw.map((h) => ({
+            folderName: h.entry.folderName,
+            folderPath: h.entry.folderPath,
+            transcribedAt: h.entry.transcribedAt,
+            title: h.data.title,
+            audioFilePath: h.data.audioFilePath ?? '',
+            score: h.score,
+            matchedFields: h.matchedFields,
+            snippet: h.snippet,
+            snippetField: h.snippetField ?? null,
+            data: {
+                title: h.data.title,
+                suggestedTitle: h.data.suggestedTitle,
+                summary: h.data.summary,
+                transcript: h.data.transcript,
+                keyPoints: h.data.keyPoints ?? [],
+                actionItems: h.data.actionItems ?? [],
+                customFields: h.data.customFields ?? {},
+                emoji: h.data.emoji,
+            },
+        }));
+        return { success: true, hits };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+});
 // Get list of recordings
 electron_1.ipcMain.handle('get-recordings', async () => {
     try {
@@ -833,5 +931,71 @@ electron_1.ipcMain.handle('open-microphone-settings', async () => {
     }
     // For Linux, there's no standard way to open microphone settings
 });
-// Register file handler service
+// Agent chat: blocks until the agent produces a final answer. During the run the
+// main process may ask the renderer to confirm a config change via the
+// 'agent-confirm-request' event; the renderer answers with 'agent-confirm-response'.
+electron_1.ipcMain.handle('agent-chat', async (_event, opts) => {
+    try {
+        const agent = getAgentService();
+        if (!agent) {
+            return { success: false, error: 'Gemini API key not configured.' };
+        }
+        const question = (opts?.question ?? '').trim();
+        if (!question)
+            return { success: false, error: 'Empty question.' };
+        const scope = opts?.scope?.kind === 'single' && typeof opts.scope.folderName === 'string'
+            ? { kind: 'single', folderName: opts.scope.folderName }
+            : { kind: 'all' };
+        const confirm = async (proposal) => {
+            if (!mainWindow || mainWindow.isDestroyed())
+                return false;
+            const id = `cfm_${++confirmIdCounter}`;
+            const approval = new Promise((resolve) => {
+                pendingConfirms.set(id, resolve);
+            });
+            mainWindow.webContents.send('agent-confirm-request', { id, proposal });
+            return approval;
+        };
+        const result = await agent.run({
+            question,
+            history: Array.isArray(opts?.history) ? opts.history : [],
+            scope,
+            confirm,
+        });
+        // The agent only mutates via set_config; replay each applied write into the
+        // runtime side-effect pipeline so shortcut/detector state matches the disk
+        // config, then push a 'config-changed' event so the renderer can re-render
+        // its toggle checkboxes without waiting for a full reload.
+        if (result.appliedActions.length > 0) {
+            const changed = {};
+            for (const action of result.appliedActions) {
+                if (action.type === 'setConfig') {
+                    changed[action.key] = action.value;
+                }
+            }
+            applyConfigSideEffects(changed);
+            broadcastConfigChanged();
+        }
+        return { success: true, result };
+    }
+    catch (error) {
+        console.error('agent-chat failed:', error);
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+});
+electron_1.ipcMain.handle('agent-confirm-response', async (_, payload) => {
+    const resolver = pendingConfirms.get(payload.id);
+    if (resolver) {
+        pendingConfirms.delete(payload.id);
+        resolver(!!payload.approved);
+    }
+    return { success: true };
+});
+// Renderer-triggered bail-out: if the user clicks "Stop" on a pending chat
+// bubble while a set_config confirm is outstanding, reject it so the awaiting
+// agent call unwinds and the input unlocks. No-op when nothing is pending.
+electron_1.ipcMain.handle('agent-cancel-pending', async () => {
+    rejectAllPendingConfirms();
+    return { success: true };
+});
 fileHandlerService.registerHandlers();

package/dist/outputService.js

@@ -134,6 +134,9 @@ function buildFrontmatter(meta) {
     if (meta.audioFilePath) {
         lines.push(`audioFilePath: ${yamlQuote(meta.audioFilePath)}`);
     }
+    if (meta.emoji) {
+        lines.push(`emoji: ${yamlQuote(meta.emoji)}`);
+    }
     lines.push('---');
     return lines.join('\n');
 }
@@ -224,6 +227,7 @@ function saveTranscription(opts) {
         customFields: opts.result.customFields,
         audioFilePath: opts.audioFilePath,
         transcribedAt,
+        emoji: opts.result.emoji,
     });
     const summaryBody = formatSummary(opts.result, opts.title);
     fs.writeFileSync(path.join(folderPath, 'summary.md'), `${frontmatter}\n\n${summaryBody}`, 'utf-8');
@@ -317,6 +321,7 @@ function readTranscription(folderPath) {
             customFields,
             audioFilePath: meta.audioFilePath,
             transcribedAt: meta.transcribedAt,
+            emoji: meta.emoji,
         };
     }
     catch {

package/dist/searchService.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_FIELDS = exports.DEFAULT_FIELDS = exports.FIELD_WEIGHTS = void 0;
+exports.makeSnippet = makeSnippet;
+exports.scoreRecord = scoreRecord;
+exports.resolveFields = resolveFields;
+exports.searchTranscriptions = searchTranscriptions;
+const outputService_1 = require("./outputService");
+exports.FIELD_WEIGHTS = {
+    title: 10,
+    summary: 5,
+    keyPoints: 3,
+    actionItems: 3,
+    transcript: 1,
+};
+exports.DEFAULT_FIELDS = ['title', 'summary', 'keyPoints', 'actionItems'];
+exports.ALL_FIELDS = ['title', 'summary', 'keyPoints', 'actionItems', 'transcript'];
+/** Extract a ~width-char snippet centered on the first occurrence of needle. */
+function makeSnippet(text, needle, width = 80, matchIndex) {
+    if (!text || !needle)
+        return '';
+    const idx = matchIndex ?? text.toLowerCase().indexOf(needle.toLowerCase());
+    if (idx === -1)
+        return '';
+    const half = Math.floor(width / 2);
+    const start = Math.max(0, idx - half);
+    const end = Math.min(text.length, idx + needle.length + half);
+    let snippet = text.slice(start, end).replace(/\s+/g, ' ').trim();
+    if (start > 0)
+        snippet = '...' + snippet;
+    if (end < text.length)
+        snippet = snippet + '...';
+    return snippet;
+}
+/** Returns the match index in haystack (lowercased) for a pre-lowercased needle, or -1. */
+function findIndex(haystack, needleLower) {
+    if (!haystack)
+        return -1;
+    return haystack.toLowerCase().indexOf(needleLower);
+}
+function firstArrayHit(haystack, needleLower) {
+    if (!haystack)
+        return undefined;
+    for (const s of haystack) {
+        const idx = s.toLowerCase().indexOf(needleLower);
+        if (idx !== -1)
+            return { text: s, index: idx };
+    }
+    return undefined;
+}
+/**
+ * Score one record against a pre-lowercased needle and pre-built scope Set.
+ * The bulk-search path hoists these out of the per-entry loop; `scoreRecord`
+ * below is a thin convenience wrapper for direct callers (tests).
+ */
+function scoreRecordPrepared(entry, data, needle, scope) {
+    if (!needle)
+        return null;
+    let score = 0;
+    const matched = [];
+    let snippetSource = '';
+    let snippetIndex = -1;
+    let snippetField;
+    const setSnippet = (field, source, index) => {
+        if (!snippetField) {
+            snippetField = field;
+            snippetSource = source;
+            snippetIndex = index;
+        }
+    };
+    if (scope.has('title') && findIndex(data.title, needle) !== -1) {
+        score += exports.FIELD_WEIGHTS.title;
+        matched.push('title');
+    }
+    {
+        const idx = scope.has('summary') ? findIndex(data.summary, needle) : -1;
+        if (idx !== -1) {
+            score += exports.FIELD_WEIGHTS.summary;
+            matched.push('summary');
+            setSnippet('summary', data.summary, idx);
+        }
+    }
+    if (scope.has('keyPoints')) {
+        const hit = firstArrayHit(data.keyPoints, needle);
+        if (hit) {
+            score += exports.FIELD_WEIGHTS.keyPoints;
+            matched.push('keyPoints');
+            setSnippet('keyPoints', hit.text, hit.index);
+        }
+    }
+    if (scope.has('actionItems')) {
+        const hit = firstArrayHit(data.actionItems, needle);
+        if (hit) {
+            score += exports.FIELD_WEIGHTS.actionItems;
+            matched.push('actionItems');
+            setSnippet('actionItems', hit.text, hit.index);
+        }
+    }
+    {
+        const idx = scope.has('transcript') ? findIndex(data.transcript, needle) : -1;
+        if (idx !== -1) {
+            score += exports.FIELD_WEIGHTS.transcript;
+            matched.push('transcript');
+            setSnippet('transcript', data.transcript, idx);
+        }
+    }
+    if (score === 0)
+        return null;
+    const snippet = snippetSource ? makeSnippet(snippetSource, needle, 80, snippetIndex) : '';
+    return { entry, data, score, matchedFields: matched, snippet, snippetField };
+}
+/** Convenience wrapper: lowercases the query and builds the scope Set per call. */
+function scoreRecord(entry, data, query, fields) {
+    return scoreRecordPrepared(entry, data, query.toLowerCase(), new Set(fields));
+}
+/** Resolve which fields to search based on CLI flags. */
+function resolveFields(opts) {
+    if (opts.field === 'all')
+        return [...exports.ALL_FIELDS];
+    if (opts.field)
+        return [opts.field];
+    return opts.includeTranscript ? [...exports.ALL_FIELDS] : [...exports.DEFAULT_FIELDS];
+}
+/** Run a search against the local transcriptions archive. */
+function searchTranscriptions(dataPath, opts) {
+    const entries = (0, outputService_1.listTranscriptions)(dataPath, 0);
+    const fields = opts.fields ?? exports.DEFAULT_FIELDS;
+    const needle = opts.query.toLowerCase();
+    const scope = new Set(fields);
+    const hits = [];
+    for (const entry of entries) {
+        const data = (0, outputService_1.readTranscription)(entry.folderPath);
+        if (!data)
+            continue;
+        const hit = scoreRecordPrepared(entry, data, needle, scope);
+        if (hit)
+            hits.push(hit);
+    }
+    hits.sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        return (b.entry.transcribedAt || '').localeCompare(a.entry.transcribedAt || '');
+    });
+    const limit = opts.limit;
+    if (limit && limit > 0)
+        return hits.slice(0, limit);
+    return hits; // limit=0 or undefined → return all
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "listener-ai",
-  "version": "1.7.0",
+  "version": "2.0.0",
   "description": "A lightweight desktop application for recording and transcribing meetings with AI-powered notes.",
   "main": "dist/main.js",
   "bin": {
@@ -12,12 +12,14 @@
     "dist/configService.js",
     "dist/geminiService.js",
     "dist/outputService.js",
+    "dist/searchService.js",
+    "dist/agentService.js",
     "dist/services/ffmpegManager.js"
   ],
   "scripts": {
     "start": "pnpm run build && electron .",
     "build": "tsc",
-    "test": "tsc && node --test dist/meetingDetectorService.test.js",
+    "test": "tsc && node --test dist/meetingDetectorService.test.js dist/searchService.test.js dist/agentService.test.js",
     "dist": "pnpm run build && electron-builder",
     "dist:mac": "pnpm run build && electron-builder --mac",
     "dist:mac-x64": "pnpm run build && electron-builder --mac --x64",