@pcircle/memesh 4.3.0 → 4.5.0

package/dist/transports/cli/cli.js

@@ -8,6 +8,7 @@ import { openDatabase, closeDatabase, getDatabase, reindexFts, allowVectorIndexR
 import { remember, recallWithConflicts, forget, exportMemories, importMemories, learn, reindex, setPinned } from '../../core/operations.js';
 import { verifyAgentWork } from '../../core/verifier.js';
 import { readConfig, writeConfig, maskApiKey, detectCapabilities } from '../../core/config.js';
+import { MAX_LANGUAGE_LENGTH, languageValueError } from '../../core/output-language.js';
 import { getDbPath } from '../../core/paths.js';
 import { flushPendingEmbeddings, canRefillVectorIndex } from '../../core/embedder.js';
 async function withDatabase(fn) {
@@ -52,6 +53,14 @@ program
         opts.type = 'note';
         if (!opts.obs || opts.obs.length === 0)
             opts.obs = [String(text)];
+        else
+            opts.obs = [...opts.obs, String(text)];
+    }
+    else if (text) {
+        if (!opts.obs || opts.obs.length === 0)
+            opts.obs = [String(text)];
+        else
+            opts.obs = [...opts.obs, String(text)];
     }
     if (!opts.name || !opts.type) {
         console.error('Error: provide --name and --type, OR pass quick-capture text as a positional arg.\n' +
@@ -108,11 +117,25 @@ program
             console.log('No results found.');
         }
         else {
+            const allSemantic = query && entities.every((e) => e.match?.source === 'semantic');
+            if (allSemantic) {
+                console.log('No keyword matches. Closest memories by meaning — may be unrelated:');
+            }
             for (const e of entities) {
                 const badge = e.archived ? ' [archived]' : '';
-                console.log(`  ${e.name}${badge} (${e.type})`);
+                const semantic = e.match?.source === 'semantic'
+                    ? ` (~${Math.round((e.match.relevance ?? 0) * 100)}% semantic)`
+                    : '';
+                console.log(`  ${e.name}${badge} (${e.type})${semantic}`);
                 for (const obs of e.observations.slice(0, 3)) {
-                    console.log(`    - ${obs}`);
+                    let shown = obs;
+                    if (obs.length > 500) {
+                        let head = obs.slice(0, 500);
+                        if (/[\uD800-\uDBFF]$/.test(head))
+                            head = head.slice(0, -1);
+                        shown = `${head} … (+${obs.length - head.length} more chars)`;
+                    }
+                    console.log(`    - ${shown}`);
                 }
                 if (e.observations.length > 3) {
                     console.log(`    ... +${e.observations.length - 3} more`);
@@ -168,6 +191,8 @@ function registerPinCommand(name, description, pinned, onFound) {
                 console.log(JSON.stringify(result));
             else
                 console.log(result.found ? onFound(opts.name) : `Entity "${opts.name}" not found`);
+            if (!result.found)
+                process.exitCode = 1;
         });
     });
 }
@@ -306,17 +331,25 @@ program
     .action(async (workdir, opts) => {
     await withDatabase(() => {
         let externalReport;
-        if (opts.report) {
-            const raw = fs.readFileSync(opts.report, 'utf8');
-            externalReport = JSON.parse(raw);
-        }
-        const result = verifyAgentWork({
-            agent_id: opts.agentId,
-            workdir: path.resolve(workdir),
-            base: opts.base,
-            claim: opts.expectedFiles != null ? { expected_files: opts.expectedFiles } : undefined,
-            report: externalReport,
-        });
+        let result;
+        try {
+            if (opts.report) {
+                const raw = fs.readFileSync(opts.report, 'utf8');
+                externalReport = JSON.parse(raw);
+            }
+            result = verifyAgentWork({
+                agent_id: opts.agentId,
+                workdir: path.resolve(workdir),
+                base: opts.base,
+                claim: opts.expectedFiles != null ? { expected_files: opts.expectedFiles } : undefined,
+                report: externalReport,
+            });
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            console.error('Nothing was checked (exit 2 = unverified).');
+            process.exit(2);
+        }
         if (opts.json) {
             console.log(JSON.stringify(result, null, 2));
         }
@@ -362,10 +395,18 @@ const ALLOWED_KEYS = new Set([
     'enableAgenticOrchestration',
     'autoCapture',
     'llmFallbacks',
+    'language',
 ]);
 const KEY_VALIDATORS = {
     'llm.provider': (v) => ['anthropic', 'openai', 'ollama'].includes(v) ? null : `must be one of: anthropic, openai, ollama`,
-    'embedder.provider': (v) => ['onnx', 'openai', 'ollama'].includes(v) ? null : `must be one of: onnx, openai, ollama`,
+    'language': (v) => {
+        if (v.trim().length === 0)
+            return 'must not be blank — use `memesh config unset language` to clear it';
+        if (v.length > MAX_LANGUAGE_LENGTH)
+            return `must be ${MAX_LANGUAGE_LENGTH} characters or fewer (a language name or locale code)`;
+        return languageValueError(v);
+    },
+    'embedder.provider': (v) => ['openai', 'ollama'].includes(v) ? null : `must be one of: openai, ollama`,
     'autoUpdate': (v) => ['off', 'patch', 'minor', 'major'].includes(v) ? null : `must be one of: off, patch, minor, major`,
     'llmFallbacks': (v) => {
         let parsed;
@@ -548,13 +589,13 @@ program
 });
 program
     .command('serve')
-    .description('Start HTTP API server')
+    .description('Start the HTTP API server and web dashboard')
     .option('--port <port>', 'Port number', '3737')
     .option('--host <host>', 'Host to bind', '127.0.0.1')
-    .option('--allow-remote', 'Allow binding to non-loopback hosts (no auth layer is added)')
+    .option('--allow-remote', 'Allow binding to non-loopback hosts. A bearer token is generated and REQUIRED for every /v1 request — the startup output shows where it lives and how to rotate it.')
     .action(async (opts) => {
     const { startServer } = await import('../http/server.js');
-    startServer(opts.host, parseInt(opts.port, 10), { allowRemote: opts.allowRemote });
+    startServer(opts.host, parseInt(opts.port, 10), { allowRemote: opts.allowRemote, autoUpdateCheck: true });
 });
 program
     .command('update')
@@ -849,18 +890,118 @@ dreamCmd
     .option('--max-llm-calls <n>', 'Hard cap on LLM calls (default 100)', (v) => parseInt(v, 10))
     .option('--window-days <n>', 'Look-back window in days (default 56 = 8 weeks)', (v) => parseInt(v, 10))
     .option('--validate', 'Run a second LLM pass to cross-check each digest against its sources (doubles LLM calls per proposal; surfaces under flow=digest_validator in `memesh telemetry`)')
+    .option('--from-transcripts', 'EXPERIMENTAL: mine Claude Code session transcripts for this project (decisions/lessons/facts hidden in the conversation) and STAGE them as proposals for `dream accept`, instead of clustering existing entities. Scoped to the current project only — --project does not apply here. With --dry-run, lists sessions and conversation-turn counts without calling an LLM.')
+    .option('--if-due', 'For a scheduler (cron/launchd): only mine if `transcriptMining` is enabled in config AND at least --min-interval-hours have passed since this project was last mined; otherwise exit 0 doing nothing. Lets one frequently-firing entry self-throttle. Only meaningful with --from-transcripts.')
+    .option('--min-interval-hours <n>', 'With --if-due: minimum hours between mined runs for this project (default 24).', (v) => parseInt(v, 10))
     .action(async (opts) => {
+    if (opts.fromTranscripts) {
+        const windowDays = typeof opts.windowDays === 'number' && !Number.isNaN(opts.windowDays) ? opts.windowDays : 3;
+        if (opts.dryRun) {
+            const { scanTranscripts } = await import('../../core/transcript-source.js');
+            const { countConversationTurns } = await import('../../core/transcript-extractor.js');
+            const sessions = scanTranscripts({ windowDays });
+            console.log(`[dry-run] transcript sessions for this project in the last ${windowDays} day(s): ${sessions.length}`);
+            let totalTurns = 0;
+            for (const s of sessions) {
+                const turns = countConversationTurns(s.path);
+                totalTurns += turns;
+                console.log(`  ${s.sessionId}  ${turns} conversation turns  ${s.lineCount} lines  ${(s.sizeBytes / 1024).toFixed(0)}KB  ${s.modifiedAt}`);
+            }
+            console.log(`  total: ${totalTurns} conversation turns across ${sessions.length} session(s)`);
+            console.log('');
+            console.log('Run without --dry-run to extract high-value memories and stage them as proposals.');
+            return;
+        }
+        if (opts.ifDue) {
+            const { isTranscriptMiningEnabled } = await import('../../core/config.js');
+            if (!isTranscriptMiningEnabled(readConfig())) {
+                console.log('Scheduled transcript mining is off (opt-in). Enable it with `memesh config set transcriptMining true`; this scheduled run will then start mining when due.');
+                return;
+            }
+            const { getProjectName } = await import('../../core/paths.js');
+            const { lastTranscriptMineAt, transcriptMiningDue } = await import('../../core/transcript-source.js');
+            const projectKey = getProjectName(process.cwd());
+            const intervalH = typeof opts.minIntervalHours === 'number' && !Number.isNaN(opts.minIntervalHours) ? opts.minIntervalHours : 24;
+            const last = lastTranscriptMineAt(projectKey);
+            if (!transcriptMiningDue(Date.now(), last, intervalH)) {
+                const agoH = last === null ? null : (Date.now() - last) / 3600_000;
+                console.log(`Not due yet: this project was mined ${agoH === null ? 'recently' : `${agoH.toFixed(1)}h ago`}; interval is ${intervalH}h. Nothing to do.`);
+                return;
+            }
+        }
+        if (opts.project) {
+            console.log('note: --project does not scope --from-transcripts — the transcript source is always the current project. Ignoring --project.');
+        }
+        await withDatabase(async () => {
+            const { runTranscriptSource } = await import('../../core/transcript-extractor.js');
+            const { getDatabase } = await import('../../db.js');
+            const cfg = readConfig();
+            const llm = detectCapabilities().llm;
+            if (!llm) {
+                console.error('No LLM configured. Run `memesh config set llm.provider <anthropic|openai|ollama>` first (or set ANTHROPIC_API_KEY / OPENAI_API_KEY).');
+                console.error('LLM is required for `--from-transcripts` because extracting durable memory from prose is a semantic decision, not a rule.');
+                process.exit(1);
+            }
+            const result = await runTranscriptSource(getDatabase(), llm, {
+                windowDays,
+                maxLlmCalls: opts.maxLlmCalls,
+                fallbacks: cfg.llmFallbacks,
+            });
+            const { getProjectName } = await import('../../core/paths.js');
+            const { recordTranscriptMine } = await import('../../core/transcript-source.js');
+            recordTranscriptMine(getProjectName(process.cwd()), Date.now());
+            console.log(`Transcript mining complete in ${result.durationMs}ms`);
+            console.log(`  sessions scanned:    ${result.sessionsScanned}`);
+            console.log(`  LLM calls:           ${result.llmCalls}`);
+            console.log(`  candidates extracted: ${result.candidatesExtracted}`);
+            console.log(`  proposals created:   ${result.proposalsCreated}`);
+            if (result.duplicatesSkipped > 0)
+                console.log(`  duplicates skipped:  ${result.duplicatesSkipped} (already a pending proposal)`);
+            if (result.nearDuplicatesSkipped > 0) {
+                console.log(`  near-duplicates skipped: ${result.nearDuplicatesSkipped} candidate(s) skipped as near-duplicates of existing memories`);
+                for (const d of result.nearDuplicates) {
+                    console.log(`    - "${d.candidateName}" ~= existing "${d.matchedEntityName}" (distance ${d.distance.toFixed(3)})`);
+                }
+            }
+            if (result.secretsDropped > 0)
+                console.log(`  secret-bearing candidates dropped: ${result.secretsDropped}`);
+            if (result.llmFailures > 0)
+                console.log(`  LLM call failures:   ${result.llmFailures} (sessions not mined — retry when the provider is reachable)`);
+            if (result.parseFailures > 0)
+                console.log(`  unparsable replies:  ${result.parseFailures} (chunk reply not valid JSON — likely truncated; those candidates were lost, retry)`);
+            if (result.truncatedTurns > 0) {
+                console.log(`  size-cap truncation: ${result.truncatedTurns} conversation turn(s) beyond the cap were NOT analysed`);
+                for (const t of result.truncatedSessions) {
+                    console.log(`    - session ${t.sessionId}: ${t.truncatedTurns} tail turn(s) not analysed`);
+                }
+            }
+            if (result.skipped.length > 0) {
+                const reasonCounts = new Map();
+                for (const s of result.skipped)
+                    reasonCounts.set(s.reason, (reasonCounts.get(s.reason) ?? 0) + 1);
+                console.log(`  skipped:             ${result.skipped.length}`);
+                for (const [reason, n] of reasonCounts)
+                    console.log(`    - ${reason}${n > 1 ? ` (×${n})` : ''}`);
+            }
+            if (result.proposalsCreated > 0) {
+                console.log('');
+                console.log('Review with: memesh dream list');
+                console.log('Accept:      memesh dream accept <id>');
+            }
+        });
+        return;
+    }
     await withDatabase(async () => {
         const { runDreamer } = await import('../../core/dreamer.js');
-        const { readConfig } = await import('../../core/config.js');
         const { getDatabase } = await import('../../db.js');
         const cfg = readConfig();
-        if (!cfg.llm) {
-            console.error('No LLM configured. Run `memesh config set llm.provider <anthropic|openai|ollama>` first.');
+        const llm = detectCapabilities().llm;
+        if (!llm) {
+            console.error('No LLM configured. Run `memesh config set llm.provider <anthropic|openai|ollama>` first (or set ANTHROPIC_API_KEY / OPENAI_API_KEY).');
             console.error('LLM is required for `memesh dream` because consolidation is a semantic decision, not a rule.');
             process.exit(1);
         }
-        const result = await runDreamer(getDatabase(), cfg.llm, {
+        const result = await runDreamer(getDatabase(), llm, {
             project: opts.project,
             dryRun: !!opts.dryRun,
             maxLlmCalls: opts.maxLlmCalls,
@@ -900,14 +1041,15 @@ dreamCmd
     .action(async (opts) => {
     await withDatabase(async () => {
         const { runPatternDetector } = await import('../../core/dreamer.js');
-        const { readConfig } = await import('../../core/config.js');
         const { getDatabase } = await import('../../db.js');
         const cfg = readConfig();
-        if (!cfg.llm) {
+        const llm = detectCapabilities().llm;
+        if (!llm) {
             console.error('No LLM configured. Pattern detection requires an LLM.');
+            console.error('Run `memesh config set llm.provider <anthropic|openai|ollama>` first (or set ANTHROPIC_API_KEY / OPENAI_API_KEY).');
             process.exit(1);
         }
-        const result = await runPatternDetector(getDatabase(), cfg.llm, {
+        const result = await runPatternDetector(getDatabase(), llm, {
             project: opts.project,
             dryRun: !!opts.dryRun,
             maxLlmCalls: opts.maxLlmCalls,
@@ -952,12 +1094,48 @@ dreamCmd
         console.log(`${proposals.length} ${opts.status} proposal(s):`);
         console.log('');
         for (const p of proposals) {
-            console.log(`  #${p.id}  [${p.project}/${p.cluster_key}]  ${p.source_count} sources → "${p.digest_name}"`);
-            console.log(`         ${p.digest_observations_preview}`);
+            const srcLabel = p.source_kind === 'transcript' ? ' (transcript)' : '';
+            console.log(`  #${p.id}  [${p.project}/${p.cluster_key}]${srcLabel}  ${p.source_count} source(s) → "${p.digest_name}"`);
+            if (p.digest_observations_preview !== null) {
+                console.log(`         ${p.digest_observations_preview}`);
+            }
             console.log(`         created: ${p.created_at}`);
             console.log('');
         }
-        console.log(`Apply: memesh dream accept <id>   |   Reject: memesh dream reject <id>`);
+        console.log(`Inspect: memesh dream show <id>   |   Apply: memesh dream accept <id>   |   Reject: memesh dream reject <id>`);
+    });
+});
+dreamCmd
+    .command('show <id>')
+    .description('Show a proposal in full — name, type, ALL observations, tags, source — so you can review the whole thing before accepting')
+    .option('--json', 'Output JSON')
+    .action(async (id, opts) => {
+    await withDatabase(async () => {
+        const { getProposalDetail } = await import('../../core/dreamer.js');
+        const { getDatabase } = await import('../../db.js');
+        const detail = getProposalDetail(getDatabase(), parseInt(id, 10));
+        if (!detail) {
+            console.error(`proposal #${id} not found`);
+            console.error('See ids with: memesh dream list');
+            process.exit(1);
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(detail, null, 2));
+            return;
+        }
+        console.log(`Proposal #${detail.id}  [${detail.project}/${detail.cluster_key}]  source: ${detail.source_kind}  status: ${detail.status}`);
+        console.log(`created: ${detail.created_at}`);
+        console.log('');
+        console.log(`name: ${detail.digest.name}`);
+        console.log(`type: ${detail.digest.type}`);
+        console.log(`observations (${detail.digest.observations.length}):`);
+        for (const o of detail.digest.observations)
+            console.log(`  - ${o}`);
+        if (detail.digest.tags.length > 0)
+            console.log(`tags: ${detail.digest.tags.join(', ')}`);
+        console.log(`source: ${JSON.stringify(detail.source)}`);
+        console.log('');
+        console.log(`Accept: memesh dream accept ${detail.id}   |   Reject: memesh dream reject ${detail.id}`);
     });
 });
 dreamCmd
@@ -969,7 +1147,16 @@ dreamCmd
         const { getDatabase } = await import('../../db.js');
         const { KnowledgeGraph } = await import('../../knowledge-graph.js');
         const kg = new KnowledgeGraph(getDatabase());
-        const result = applyProposal(getDatabase(), parseInt(id, 10), kg);
+        let result;
+        try {
+            result = applyProposal(getDatabase(), parseInt(id, 10), kg);
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            console.error('See pending ids with: memesh dream list');
+            process.exit(1);
+        }
+        await flushPendingEmbeddings();
         console.log(`Applied proposal #${result.proposalId}`);
         console.log(`  digest entity: ${result.digestEntityName}`);
         console.log(`  sources archived: ${result.sourcesArchived}`);
@@ -983,7 +1170,14 @@ dreamCmd
     await withDatabase(async () => {
         const { rejectProposal } = await import('../../core/dreamer.js');
         const { getDatabase } = await import('../../db.js');
-        rejectProposal(getDatabase(), parseInt(id, 10), opts.reason);
+        try {
+            rejectProposal(getDatabase(), parseInt(id, 10), opts.reason);
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            console.error('See pending ids with: memesh dream list');
+            process.exit(1);
+        }
         console.log(`Rejected proposal #${id}`);
     });
 });
@@ -1155,9 +1349,8 @@ program
                 console.error('❌ Could not produce a test embedding at this database\'s vector width, so\n' +
                     '   the index was left untouched. Rebuilding it deletes every stored\n' +
                     '   embedding, and nothing here could regenerate them.\n' +
-                    '   Check that your OpenAI API key is valid, or that Ollama is running, or\n' +
-                    '   install @huggingface/transformers for local embeddings — then run this\n' +
-                    '   again. `memesh doctor` reports which provider is configured.');
+                    '   Check that Ollama is running (or that your OpenAI API key is valid) —\n' +
+                    '   then run this again. `memesh doctor` reports which provider is configured.');
                 process.exit(1);
             }
         }
@@ -1274,40 +1467,11 @@ program.action(async () => {
     if (stray.length > 0) {
         console.error(`Error: unknown command '${stray[0]}'.`);
         console.error(`       Run 'memesh --help' to see available commands.`);
-        process.exit(1);
-    }
-    const { startServer } = await import('../http/server.js');
-    const server = startServer('127.0.0.1', 0);
-    await new Promise((resolve, reject) => {
-        server.once('listening', resolve);
-        server.once('error', reject);
-    });
-    const addr = server.address();
-    if (!addr) {
-        console.error('Failed to start dashboard server');
-        process.exit(1);
-    }
-    const url = `http://127.0.0.1:${addr.port}/dashboard`;
-    console.log(`MeMesh dashboard: ${url}`);
-    console.log('Press Ctrl+C to stop.');
-    const { execFile } = await import('child_process');
-    if (process.platform === 'darwin') {
-        execFile('open', [url]);
-    }
-    else if (process.platform === 'win32') {
-        execFile('cmd.exe', ['/c', 'start', '', url]);
-    }
-    else {
-        execFile('xdg-open', [url]);
+        process.exitCode = 1;
+        return;
     }
-    process.on('SIGINT', () => {
-        server.close();
-        try {
-            closeDatabase();
-        }
-        catch { }
-        process.exit(0);
-    });
+    program.outputHelp();
+    process.exitCode = 0;
 });
 program.parse();
 //# sourceMappingURL=cli.js.map