listener-ai 2.5.0 → 2.6.0

package/README.md

@@ -41,8 +41,18 @@ listener config set notionDatabaseId <your-id>
 ```bash
 listener recording.mp3                # Transcribe to default output dir
 listener recording.m4a --output ./    # Transcribe to current directory
-listener config list                  # Show all config values
+listener transcript recording.wav     # Print transcript to stdout (no summary)
+listener transcript recording.wav -o out.txt
+                                      # Write transcript to a file
+listener transcript recording.wav --prompt "Translate to English while transcribing"
+                                      # Override the default transcription instruction
+listener config list                  # Show all config values (secrets masked)
+listener config get <key>             # Print one config value
+listener config set <key> <value>     # Set a config value
+listener config unset <key>           # Clear a config value (falls back to default)
 listener config path                  # Print config file path
+listener --version                    # Print CLI version
+listener --help                       # Show usage
 ```
 
 Supported formats: mp3, m4a, wav, ogg, flac, aac, wma, opus, webm

package/dist/cli.js

@@ -57,32 +57,54 @@ const SUPPORTED_EXTENSIONS = new Set([
     '.opus',
     '.webm',
 ]);
-function usage() {
-    process.stderr.write('Usage: listener <file> [--output <dir>]    Transcribe an audio file\n' +
-        '       listener list [--limit <n>]         List past transcriptions\n' +
-        '       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 merge <ref1> <ref2> [<ref3>...] [--title <t>]\n' +
-        '                                           Concat the source audio of two or more notes,\n' +
-        '                                           re-transcribe end-to-end, and save as a new note\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' +
-        '\n' +
-        'Options:\n' +
-        '  --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 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');
+const VERSION = (() => {
+    try {
+        const pkgPath = path.join(__dirname, '..', 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        return pkg.version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+})();
+const USAGE_TEXT = 'Usage: listener <file> [--output <dir>]    Transcribe an audio file into a meeting note\n' +
+    '       listener transcript <file> [--output <path>] [--prompt <text>]\n' +
+    '                                           Transcribe to plain text only (no summary)\n' +
+    '       listener list [--limit <n>]         List past transcriptions\n' +
+    '       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 merge <ref1> <ref2> [<ref3>...] [--title <t>]\n' +
+    '                                           Concat the source audio of two or more notes,\n' +
+    '                                           re-transcribe end-to-end, and save as a new note\n' +
+    '       listener ask <question> [--ref <ref>]\n' +
+    '                                           Ask the AI agent about saved meetings or settings\n' +
+    '       listener config list|get|set|unset|path\n' +
+    '                                           Manage configuration\n' +
+    '\n' +
+    '<ref> is a number from `listener list` or a folder name.\n' +
+    '\n' +
+    'Options:\n' +
+    '  --output, -o <path>\n' +
+    '                   Parent directory for the output folder (transcribe);\n' +
+    '                   destination file or directory (transcript)\n' +
+    '  --prompt <text>  Override the default transcription instruction (transcript)\n' +
+    '  --limit <n>      Max results (0 = all, default: 20)\n' +
+    '  --json           Export as JSON instead of markdown\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' +
+    '  --version, -V    Print CLI version\n' +
+    '  --help, -h       Show this help message\n';
+function usageError() {
+    process.stderr.write(USAGE_TEXT);
     process.exit(1);
 }
+function showHelp() {
+    process.stdout.write(USAGE_TEXT);
+    process.exit(0);
+}
 const KNOWN_CONFIG_KEYS = [
     'geminiApiKey',
     'geminiModel',
@@ -90,23 +112,124 @@ const KNOWN_CONFIG_KEYS = [
     'notionApiKey',
     'notionDatabaseId',
     'autoMode',
+    'meetingDetection',
+    'displayDetection',
     'globalShortcut',
+    'knownWords',
+    'summaryPrompt',
+    'maxRecordingMinutes',
+    'recordingReminderMinutes',
     'minRecordingSeconds',
+    'recordSystemAudio',
+    'slackWebhookUrl',
+    'slackAutoShare',
 ];
+function isSensitiveKey(key) {
+    const lk = key.toLowerCase();
+    return lk.includes('key') || lk.includes('webhook');
+}
 function maskValue(key, value) {
     if (value == null || value === '')
         return '(not set)';
-    if (key.toLowerCase().includes('key')) {
-        return value.length > 4 ? `****${value.slice(-4)}` : '****';
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return '(none)';
+        const joined = value.map((x) => String(x)).join(', ');
+        return joined.length > 60 ? `${joined.slice(0, 57)}...` : joined;
+    }
+    const str = String(value);
+    if (isSensitiveKey(key)) {
+        return str.length > 4 ? `****${str.slice(-4)}` : '****';
+    }
+    if (str.length > 60)
+        return `${str.slice(0, 57)}...`;
+    return str;
+}
+function parseBool(key, v) {
+    if (v !== 'true' && v !== 'false') {
+        process.stderr.write(`Error: ${key} must be "true" or "false"\n`);
+        process.exit(1);
+    }
+    return v === 'true';
+}
+function parseNonNegInt(key, v) {
+    const n = Number.parseInt(v, 10);
+    if (Number.isNaN(n) || n < 0 || String(n) !== v.trim()) {
+        process.stderr.write(`Error: ${key} must be a non-negative integer\n`);
+        process.exit(1);
+    }
+    return n;
+}
+function parseKnownWords(v) {
+    return v
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+function applyConfigSet(config, key, value) {
+    switch (key) {
+        case 'geminiApiKey':
+            config.setGeminiApiKey(value);
+            return;
+        case 'geminiModel':
+            config.setGeminiModel(value);
+            return;
+        case 'geminiFlashModel':
+            config.setGeminiFlashModel(value);
+            return;
+        case 'notionApiKey':
+            config.setNotionApiKey(value);
+            return;
+        case 'notionDatabaseId':
+            config.setNotionDatabaseId(value);
+            return;
+        case 'autoMode':
+            config.setAutoMode(parseBool('autoMode', value));
+            return;
+        case 'meetingDetection':
+            config.updateConfig({ meetingDetection: parseBool('meetingDetection', value) });
+            return;
+        case 'displayDetection':
+            config.setDisplayDetection(parseBool('displayDetection', value));
+            return;
+        case 'globalShortcut':
+            config.setGlobalShortcut(value);
+            return;
+        case 'knownWords':
+            config.setKnownWords(parseKnownWords(value));
+            return;
+        case 'summaryPrompt':
+            config.setSummaryPrompt(value);
+            return;
+        case 'maxRecordingMinutes':
+            config.setMaxRecordingMinutes(parseNonNegInt('maxRecordingMinutes', value));
+            return;
+        case 'recordingReminderMinutes':
+            config.setRecordingReminderMinutes(parseNonNegInt('recordingReminderMinutes', value));
+            return;
+        case 'minRecordingSeconds':
+            config.setMinRecordingSeconds(parseNonNegInt('minRecordingSeconds', value));
+            return;
+        case 'recordSystemAudio':
+            config.setRecordSystemAudio(parseBool('recordSystemAudio', value));
+            return;
+        case 'slackWebhookUrl':
+            config.setSlackWebhookUrl(value);
+            return;
+        case 'slackAutoShare':
+            config.setSlackAutoShare(parseBool('slackAutoShare', value));
+            return;
     }
-    return value;
 }
 function handleConfig(subArgs) {
     const dataPath = (0, dataPath_1.getDataPath)();
     const config = new configService_1.ConfigService(dataPath);
     const sub = subArgs[0];
-    if (!sub || sub === '--help') {
-        usage();
+    if (!sub) {
+        usageError();
+    }
+    if (sub === '--help' || sub === '-h') {
+        showHelp();
     }
     if (sub === 'path') {
         process.stdout.write(`${config.getConfigPath()}\n`);
@@ -116,8 +239,7 @@ function handleConfig(subArgs) {
         const all = config.getAllConfig();
         for (const key of KNOWN_CONFIG_KEYS) {
             const raw = all[key];
-            const display = maskValue(key, raw == null ? undefined : String(raw));
-            process.stdout.write(`${key}=${display}\n`);
+            process.stdout.write(`${key}=${maskValue(key, raw)}\n`);
         }
         return;
     }
@@ -134,7 +256,12 @@ function handleConfig(subArgs) {
         }
         const all = config.getAllConfig();
         const val = all[key];
-        process.stdout.write(`${val ?? ''}\n`);
+        if (Array.isArray(val)) {
+            process.stdout.write(`${val.join(',')}\n`);
+        }
+        else {
+            process.stdout.write(`${val ?? ''}\n`);
+        }
         return;
     }
     if (sub === 'set') {
@@ -149,35 +276,27 @@ function handleConfig(subArgs) {
             process.stderr.write(`Known keys: ${KNOWN_CONFIG_KEYS.join(', ')}\n`);
             process.exit(1);
         }
-        const setters = {
-            geminiApiKey: (v) => config.setGeminiApiKey(v),
-            geminiModel: (v) => config.setGeminiModel(v),
-            geminiFlashModel: (v) => config.setGeminiFlashModel(v),
-            notionApiKey: (v) => config.setNotionApiKey(v),
-            notionDatabaseId: (v) => config.setNotionDatabaseId(v),
-            autoMode: (v) => {
-                if (v !== 'true' && v !== 'false') {
-                    process.stderr.write('Error: autoMode must be "true" or "false"\n');
-                    process.exit(1);
-                }
-                config.setAutoMode(v === 'true');
-            },
-            globalShortcut: (v) => config.setGlobalShortcut(v),
-            minRecordingSeconds: (v) => {
-                const n = Number.parseInt(v, 10);
-                if (Number.isNaN(n) || n < 0 || String(n) !== v.trim()) {
-                    process.stderr.write('Error: minRecordingSeconds must be a non-negative integer (0 disables)\n');
-                    process.exit(1);
-                }
-                config.setMinRecordingSeconds(n);
-            },
-        };
-        setters[key](value);
+        applyConfigSet(config, key, value);
         process.stderr.write(`Set ${key}\n`);
         return;
     }
+    if (sub === 'unset') {
+        const key = subArgs[1];
+        if (!key) {
+            process.stderr.write('Error: Missing key. Usage: listener config unset <key>\n');
+            process.exit(1);
+        }
+        if (!KNOWN_CONFIG_KEYS.includes(key)) {
+            process.stderr.write(`Error: Unknown key: ${key}\n`);
+            process.stderr.write(`Known keys: ${KNOWN_CONFIG_KEYS.join(', ')}\n`);
+            process.exit(1);
+        }
+        config.unsetKey(key);
+        process.stderr.write(`Unset ${key}\n`);
+        return;
+    }
     process.stderr.write(`Error: Unknown config command: ${sub}\n`);
-    usage();
+    usageError();
 }
 async function resolveRef(ref, dataPath) {
     if (/^\d+$/.test(ref)) {
@@ -312,6 +431,8 @@ async function handleExport(args) {
                 /* ignore */
             }
         }
+        const liveNotes = (0, outputService_1.parseLiveNotesField)(meta.liveNotes);
+        const highlights = (0, outputService_1.parseHighlightsField)(meta.highlights);
         const obj = {
             title: meta.title || '',
             transcribedAt: meta.transcribedAt || '',
@@ -319,6 +440,8 @@ async function handleExport(args) {
             keyPoints: meta.keyPoints || [],
             actionItems: meta.actionItems || [],
             customFields,
+            ...(liveNotes ? { liveNotes } : {}),
+            ...(highlights ? { highlights } : {}),
         };
         if (includeTranscript) {
             obj.transcript = meta.transcript || '';
@@ -548,10 +671,112 @@ async function handleAsk(args) {
         }
     }
 }
+async function handleTranscript(args) {
+    let filePath;
+    let outputArg;
+    let promptText;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if ((a === '--output' || a === '-o') && i + 1 < args.length) {
+            outputArg = args[++i];
+            continue;
+        }
+        if (a === '--prompt' && i + 1 < args.length) {
+            promptText = args[++i];
+            continue;
+        }
+        if (a.startsWith('-')) {
+            process.stderr.write(`Error: Unknown option: ${a}\n`);
+            process.exit(1);
+        }
+        if (filePath) {
+            process.stderr.write(`Error: Unexpected argument: ${a}\n`);
+            process.exit(1);
+        }
+        filePath = a;
+    }
+    if (!filePath) {
+        process.stderr.write('Error: No audio file specified. Usage: listener transcript <file> [--output <path>] [--prompt <text>]\n');
+        process.exit(1);
+    }
+    filePath = path.resolve(filePath);
+    if (!fs.existsSync(filePath)) {
+        process.stderr.write(`Error: File not found: ${filePath}\n`);
+        process.exit(1);
+    }
+    const ext = path.extname(filePath).toLowerCase();
+    if (!SUPPORTED_EXTENSIONS.has(ext)) {
+        process.stderr.write(`Error: Unsupported file type: ${ext}\n`);
+        process.stderr.write(`Supported formats: ${[...SUPPORTED_EXTENSIONS].join(', ')}\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.\n' +
+            'Set GEMINI_API_KEY env var or configure via the Listener.AI app.\n');
+        process.exit(1);
+    }
+    // Resolve --output before the expensive transcription so we fail fast on a
+    // bad path. Existing directory => <dir>/<basename>.transcript.md.
+    // Anything else => the path itself, treated as a file.
+    let outputPath;
+    if (outputArg) {
+        const resolved = path.resolve(outputArg);
+        let isDir = false;
+        try {
+            isDir = fs.statSync(resolved).isDirectory();
+        }
+        catch {
+            // ENOENT or similar: treat as a file path, validated below.
+        }
+        if (isDir) {
+            outputPath = path.join(resolved, `${path.basename(filePath, ext)}.transcript.md`);
+        }
+        else {
+            outputPath = resolved;
+            const parent = path.dirname(outputPath);
+            if (!fs.existsSync(parent)) {
+                process.stderr.write(`Error: Output directory does not exist: ${parent}\n`);
+                process.exit(1);
+            }
+        }
+    }
+    const gemini = new geminiService_1.GeminiService({
+        apiKey,
+        dataPath,
+        knownWords: config.getKnownWords(),
+        proModel: config.getGeminiModel(),
+        flashModel: config.getGeminiFlashModel(),
+    });
+    process.stderr.write(`Processing: ${filePath}\n`);
+    const result = await gemini.transcribeAudio(filePath, (_percent, message) => {
+        process.stderr.write(`  ${message}\n`);
+    }, undefined, undefined, { transcriptOnly: true, transcriptionPrompt: promptText });
+    if (outputPath) {
+        fs.writeFileSync(outputPath, result.transcript, 'utf-8');
+        process.stderr.write('Done.\n');
+        process.stdout.write(`${outputPath}\n`);
+    }
+    else {
+        // Wait for the OS to drain the write before returning, so multi-MB
+        // transcripts piped to a slow consumer are not truncated on process exit.
+        const out = result.transcript.endsWith('\n') ? result.transcript : `${result.transcript}\n`;
+        await new Promise((resolve) => process.stdout.write(out, () => resolve()));
+    }
+}
 async function main() {
     const args = process.argv.slice(2);
-    if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
-        usage();
+    if (args.includes('--version') || args.includes('-V')) {
+        process.stdout.write(`listener ${VERSION}\n`);
+        return;
+    }
+    if (args.includes('--help') || args.includes('-h')) {
+        showHelp();
+    }
+    if (args.length === 0) {
+        usageError();
     }
     if (args[0] === 'config') {
         handleConfig(args.slice(1));
@@ -581,16 +806,20 @@ async function main() {
         await handleAsk(args.slice(1));
         return;
     }
+    if (args[0] === 'transcript') {
+        await handleTranscript(args.slice(1));
+        return;
+    }
     // Parse arguments
     let filePath;
     let outputDir;
     for (let i = 0; i < args.length; i++) {
-        if (args[i] === '--output' && i + 1 < args.length) {
+        if ((args[i] === '--output' || args[i] === '-o') && i + 1 < args.length) {
             outputDir = args[++i];
         }
         else if (args[i].startsWith('-')) {
             process.stderr.write(`Error: Unknown option: ${args[i]}\n`);
-            usage();
+            usageError();
         }
         else {
             filePath = args[i];
@@ -598,7 +827,7 @@ async function main() {
     }
     if (!filePath) {
         process.stderr.write('Error: No audio file specified.\n');
-        usage();
+        usageError();
     }
     // Resolve to absolute path
     filePath = path.resolve(filePath);

package/dist/configService.js

@@ -240,6 +240,10 @@ class ConfigService {
         }
         this.saveConfig();
     }
+    unsetKey(key) {
+        delete this.config[key];
+        this.saveConfig();
+    }
     getAllConfig() {
         return {
             geminiApiKey: this.getGeminiApiKey(),