@telepat/snoopy 0.1.13 → 0.1.15

package/dist/src/cli/commands/feedback.js

@@ -0,0 +1,276 @@
+import { createInterface } from 'node:readline/promises';
+import { diff } from 'jest-diff';
+import { JobsRepository } from '../../services/db/repositories/jobsRepo.js';
+import { ScanItemsRepository } from '../../services/db/repositories/scanItemsRepo.js';
+import { consolidateFeedback } from '../../services/feedback/consolidationService.js';
+import { isRichTty, printCommandScreen, printError, printInfo, printKeyValue, printMuted, printSection, printSuccess, printWarning, } from '../ui/consoleUi.js';
+const MAX_DIFF_OUTPUT_LINES = 120;
+function formatPromptDiff(oldPrompt, newPrompt) {
+    const output = diff(oldPrompt, newPrompt, {
+        aAnnotation: 'old prompt',
+        bAnnotation: 'new prompt',
+        expand: false,
+    });
+    if (!output) {
+        return null;
+    }
+    const lines = output.split('\n');
+    if (lines.length <= MAX_DIFF_OUTPUT_LINES) {
+        return { text: output, truncated: false };
+    }
+    return {
+        text: lines.slice(0, MAX_DIFF_OUTPUT_LINES).join('\n'),
+        truncated: true,
+    };
+}
+async function promptLine(message) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await rl.question(message)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+async function promptValidity() {
+    while (true) {
+        const answer = (await promptLine('Mark as (v)alid, (i)nvalid, or (q)uit: ')).toLowerCase();
+        if (answer === 'v' || answer === 'valid') {
+            return 'valid';
+        }
+        if (answer === 'i' || answer === 'invalid') {
+            return 'invalid';
+        }
+        if (answer === 'q' || answer === 'quit' || answer === 'exit') {
+            return 'quit';
+        }
+        printWarning('Please enter v, i, or q.');
+    }
+}
+async function promptRequiredReason() {
+    while (true) {
+        const answer = await promptLine('Reason (required for invalid feedback): ');
+        if (answer.length > 0) {
+            return answer;
+        }
+        printWarning('A reason is required when marking a result as invalid.');
+    }
+}
+async function promptConsolidateBeforeExit() {
+    const answer = (await promptLine('Run consolidate now before exiting? [Y/n]: ')).toLowerCase();
+    if (!answer) {
+        return true;
+    }
+    return answer !== 'n' && answer !== 'no';
+}
+function validateSubmitFlags(options) {
+    const hasValid = options.valid === true;
+    const hasInvalid = options.invalid === true;
+    if (hasValid === hasInvalid) {
+        throw new Error('Choose exactly one: --valid or --invalid.');
+    }
+    if (hasInvalid) {
+        const reason = options.reason?.trim() ?? '';
+        if (!reason) {
+            throw new Error('A reason is required when using --invalid.');
+        }
+        return { isValid: false, reason };
+    }
+    return { isValid: true, reason: null };
+}
+function printThread(commentThreadNodes) {
+    if (commentThreadNodes.length === 0) {
+        printWarning('Thread unavailable for this comment.');
+        return;
+    }
+    printSection('Thread (root -> target)');
+    commentThreadNodes.forEach((node, index) => {
+        const marker = node.isTarget ? 'target' : `depth ${node.depth}`;
+        printInfo(`${index + 1}. ${node.author} (${marker})`);
+        printMuted(`  ${node.body}`);
+    });
+}
+function printReviewItem(row, commentThreadNodes) {
+    printSection(`Result ${row.id}`);
+    printKeyValue('Type', row.type);
+    printKeyValue('Subreddit', `r/${row.subreddit}`);
+    printKeyValue('Author', row.author);
+    printKeyValue('URL', row.url);
+    printKeyValue('Posted', row.redditPostedAt);
+    if (row.title) {
+        printKeyValue('Title', row.title);
+    }
+    if (row.qualificationReason) {
+        printKeyValue('Qualification reason', row.qualificationReason);
+    }
+    if (row.type === 'comment') {
+        printThread(commentThreadNodes);
+    }
+    printSection('Content');
+    printMuted(row.body);
+}
+export async function feedbackSubmit(resultId, options = {}) {
+    printCommandScreen('Feedback', 'Submit feedback');
+    const scanItemsRepo = new ScanItemsRepository();
+    const row = scanItemsRepo.getQualifiedById(resultId);
+    if (!row) {
+        throw new Error(`Qualified result not found: ${resultId}`);
+    }
+    const { isValid, reason } = validateSubmitFlags(options);
+    const updated = scanItemsRepo.submitFeedback(resultId, isValid, reason);
+    if (!updated) {
+        throw new Error(`Failed to save feedback for result: ${resultId}`);
+    }
+    const pendingCount = scanItemsRepo.countPendingFeedbackConsolidation(row.jobId);
+    const payload = {
+        resultId,
+        saved: true,
+        feedback: {
+            validated: true,
+            isValid,
+            isValidReason: reason,
+            feedbackConsolidated: false,
+        },
+        pendingFeedbackConsolidationCount: pendingCount,
+        requiresConsolidation: pendingCount > 0,
+        recommendedNextCommand: 'snoopy feedback consolidate',
+    };
+    if (options.json) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    printSuccess(`Saved feedback for result ${resultId}.`);
+    printKeyValue('Valid', isValid ? 'yes' : 'no');
+    if (!isValid && reason) {
+        printKeyValue('Reason', reason);
+    }
+    if (pendingCount > 0) {
+        printInfo(`Consolidation pending for ${pendingCount} result(s). Run snoopy feedback consolidate.`);
+    }
+}
+async function runInteractiveReview(rows, runConsolidateOnExit) {
+    const scanItemsRepo = new ScanItemsRepository();
+    let validatedCount = 0;
+    let invalidCount = 0;
+    let earlyExit = false;
+    for (let index = 0; index < rows.length; index += 1) {
+        const row = rows[index];
+        const commentThreadNodes = row.type === 'comment' ? scanItemsRepo.listCommentThreadNodes(row.id) : [];
+        printCommandScreen('Feedback review', `Item ${index + 1}/${rows.length}`);
+        printReviewItem(row, commentThreadNodes);
+        const verdict = await promptValidity();
+        if (verdict === 'quit') {
+            earlyExit = true;
+            break;
+        }
+        const isValid = verdict === 'valid';
+        const reason = isValid ? null : await promptRequiredReason();
+        scanItemsRepo.submitFeedback(row.id, isValid, reason);
+        validatedCount += 1;
+        if (!isValid) {
+            invalidCount += 1;
+        }
+        printSuccess(`Saved feedback for ${row.id}.`);
+    }
+    printSection('Review summary');
+    printKeyValue('Validated this session', String(validatedCount));
+    printKeyValue('Marked invalid', String(invalidCount));
+    printKeyValue('Early exit', earlyExit ? 'yes' : 'no');
+    if (earlyExit) {
+        const shouldConsolidateNow = await promptConsolidateBeforeExit();
+        if (shouldConsolidateNow) {
+            await runConsolidateOnExit();
+        }
+        else {
+            printWarning('Skipping consolidate. Prompt quality will not improve until consolidate runs.');
+        }
+        return;
+    }
+    await runConsolidateOnExit();
+}
+export async function feedbackReview(jobRef, options = {}) {
+    const jobsRepo = new JobsRepository();
+    const scanItemsRepo = new ScanItemsRepository();
+    let jobId;
+    if (jobRef) {
+        const job = jobsRepo.getByRef(jobRef);
+        if (!job) {
+            throw new Error(`Job not found: ${jobRef}`);
+        }
+        jobId = job.id;
+    }
+    const limit = options.limit ?? 10;
+    const rows = scanItemsRepo.listUnvalidatedQualified(jobId, limit);
+    if (options.json) {
+        console.log(JSON.stringify(rows, null, 2));
+        return;
+    }
+    printCommandScreen('Feedback', 'Review feedback queue');
+    if (rows.length === 0) {
+        printInfo('No more results to validate. Exiting review.');
+        return;
+    }
+    if (!isRichTty()) {
+        printError('Interactive review requires a rich terminal. Use --json in non-interactive mode.');
+        return;
+    }
+    const runConsolidateOnExit = async () => {
+        printInfo('Running feedback consolidation...');
+        const result = await consolidateFeedback({ jobRef, limit });
+        printSuccess(`Consolidated ${result.totalConsolidated} result(s).`);
+        if (result.requiresConsolidation) {
+            printWarning(`Still pending: ${result.totalPendingAfter}. Run snoopy feedback consolidate again.`);
+        }
+    };
+    await runInteractiveReview(rows, runConsolidateOnExit);
+}
+export async function feedbackConsolidate(jobRef, options = {}) {
+    printCommandScreen('Feedback', 'Consolidate feedback');
+    const result = await consolidateFeedback({
+        jobRef,
+        limit: options.limit,
+    });
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (result.totalPendingBefore === 0) {
+        printInfo('No pending feedback to consolidate.');
+        return;
+    }
+    result.jobs.forEach((jobResult) => {
+        printInfo(`${jobResult.jobName} (${jobResult.jobSlug})`);
+        printKeyValue('Pending', String(jobResult.pendingCount));
+        printKeyValue('Consolidated', String(jobResult.consolidatedCount));
+        if (jobResult.error) {
+            printError(jobResult.error);
+            return;
+        }
+        if (jobResult.changeSummary && jobResult.changeSummary.length > 0) {
+            printKeyValue('Changes', jobResult.changeSummary.join(' | '));
+        }
+        if (!jobResult.promptUpdated || !jobResult.oldPrompt || !jobResult.newPrompt) {
+            return;
+        }
+        if (jobResult.oldPrompt === jobResult.newPrompt) {
+            printMuted('Prompt did not change.');
+            return;
+        }
+        const promptDiff = formatPromptDiff(jobResult.oldPrompt, jobResult.newPrompt);
+        if (!promptDiff) {
+            printMuted('Prompt updated, but no textual diff was produced.');
+            return;
+        }
+        printSection(`Prompt diff (${jobResult.jobSlug})`);
+        console.log(promptDiff.text);
+        if (promptDiff.truncated) {
+            printWarning(`Prompt diff truncated to ${MAX_DIFF_OUTPUT_LINES} lines.`);
+        }
+    });
+    if (result.requiresConsolidation) {
+        printWarning(`Consolidation incomplete. ${result.totalPendingAfter} result(s) still pending.`);
+        return;
+    }
+    printSuccess(`Consolidated ${result.totalConsolidated} result(s) across ${result.jobs.length} job(s).`);
+}
+//# sourceMappingURL=feedback.js.map

package/dist/src/cli/commands/prompt.d.ts

@@ -0,0 +1,6 @@
+interface ShowPromptOptions {
+    raw?: boolean;
+}
+export declare function showPrompt(jobRef: string, options?: ShowPromptOptions): Promise<void>;
+export declare function setPrompt(jobRef: string, promptText: string): Promise<void>;
+export {};

package/dist/src/cli/commands/prompt.js

@@ -0,0 +1,92 @@
+import { createInterface } from 'node:readline/promises';
+import { JobsRepository } from '../../services/db/repositories/jobsRepo.js';
+import { isRichTty, printCommandScreen, printError, printInfo, printKeyValue, printMuted, printSection, printSuccess, printWarning } from '../ui/consoleUi.js';
+import { editPromptInteractively } from './promptEditor.js';
+async function promptLine(message) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await rl.question(message)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+async function confirmEditPrompt() {
+    const answer = (await promptLine('Edit qualification prompt now? [y/N]: ')).toLowerCase();
+    if (!answer) {
+        return false;
+    }
+    return answer === 'y' || answer === 'yes';
+}
+function printPromptEnvelope(job) {
+    printKeyValue('Job', `${job.name} (${job.slug})`);
+    printKeyValue('Job ID', job.id);
+    printKeyValue('Updated', job.updatedAt);
+    printSection('Qualification prompt');
+    printMuted(job.qualificationPrompt);
+}
+export async function showPrompt(jobRef, options = {}) {
+    const jobsRepo = new JobsRepository();
+    const job = jobsRepo.getByRef(jobRef);
+    if (!job) {
+        printError(`Job not found: ${jobRef}`);
+        return;
+    }
+    if (options.raw) {
+        process.stdout.write(`${job.qualificationPrompt}\n`);
+        return;
+    }
+    printCommandScreen('Prompt', 'View Prompt');
+    printPromptEnvelope(job);
+    if (!isRichTty()) {
+        printInfo('Use --raw for non-interactive prompt retrieval.');
+        return;
+    }
+    const shouldEdit = await confirmEditPrompt();
+    if (!shouldEdit) {
+        printInfo('Prompt unchanged.');
+        return;
+    }
+    const updatedPrompt = await editPromptInteractively(job.qualificationPrompt);
+    if (updatedPrompt === null) {
+        printWarning('Prompt edit cancelled.');
+        return;
+    }
+    const normalizedPrompt = updatedPrompt.trim();
+    if (!normalizedPrompt) {
+        printError('Prompt cannot be empty.');
+        return;
+    }
+    if (normalizedPrompt === job.qualificationPrompt.trim()) {
+        printInfo('Prompt unchanged.');
+        return;
+    }
+    const updated = jobsRepo.updateQualificationPromptByRef(job.id, normalizedPrompt);
+    if (!updated) {
+        printError(`Failed to update prompt for job: ${job.id}`);
+        return;
+    }
+    printSuccess(`Updated qualification prompt for ${updated.name} (${updated.slug}).`);
+}
+export async function setPrompt(jobRef, promptText) {
+    const normalizedPrompt = promptText.trim();
+    if (!normalizedPrompt) {
+        throw new Error('Prompt cannot be empty.');
+    }
+    const jobsRepo = new JobsRepository();
+    const existing = jobsRepo.getByRef(jobRef);
+    if (!existing) {
+        printError(`Job not found: ${jobRef}`);
+        return;
+    }
+    const updated = jobsRepo.updateQualificationPromptByRef(existing.id, normalizedPrompt);
+    if (!updated) {
+        printError(`Failed to update prompt for job: ${existing.id}`);
+        return;
+    }
+    printCommandScreen('Prompt', 'Set Prompt');
+    printSuccess(`Updated qualification prompt for ${updated.name} (${updated.slug}).`);
+    printKeyValue('Job ID', updated.id);
+    printKeyValue('Updated', updated.updatedAt);
+}
+//# sourceMappingURL=prompt.js.map

package/dist/src/cli/commands/promptEditor.d.ts

@@ -0,0 +1 @@
+export declare function editPromptInteractively(initialValue: string): Promise<string | null>;

package/dist/src/cli/commands/promptEditor.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { AppFrame, Panel } from '../../ui/components/AppFrame.js';
+import { MultilinePrompt } from '../../ui/components/MultilinePrompt.js';
+export async function editPromptInteractively(initialValue) {
+    let result = null;
+    const app = render(_jsx(AppFrame, { subtitle: "Prompt", statusText: "Interactive editor", statusTone: "info", hints: ['Enter submit', 'Shift+Enter newline', 'Esc cancel'], children: _jsx(Panel, { title: "Edit Qualification Prompt", children: _jsx(MultilinePrompt, { label: "Qualification prompt", initialValue: initialValue, rows: 10, onSubmit: (value) => {
+                    result = value;
+                    app.unmount();
+                }, onCancel: () => {
+                    result = null;
+                    app.unmount();
+                } }) }) }));
+    await app.waitUntilExit();
+    return result;
+}
+//# sourceMappingURL=promptEditor.js.map

package/dist/src/cli/flows/jobAddFlow.js

@@ -128,7 +128,7 @@ export function JobAddFlow({ hasApiKey, existingApiKey, canPersistApiKey, startu
                         } })] }) }));
     }
     if (stage === 'model') {
-        return (_jsx(FlowFrame, { transcript: transcript, statusText: "Choose model", statusTone: "info", children: _jsxs(Panel, { title: "Step 3: Model", children: [_jsx(Text, { color: uiTheme.ink.warning, children: "Model selection (default moonshotai/kimi-k2.5)" }), _jsx(TextPrompt, { label: "Model ID", initialValue: model.trim() || defaultModel, onSubmit: (value) => {
+        return (_jsx(FlowFrame, { transcript: transcript, statusText: "Choose model", statusTone: "info", children: _jsxs(Panel, { title: "Step 3: Model", children: [_jsx(Text, { color: uiTheme.ink.warning, children: "Model selection (default deepseek/deepseek-v4-pro)" }), _jsx(TextPrompt, { label: "Model ID", initialValue: model.trim() || defaultModel, onSubmit: (value) => {
                             const chosenModel = value.trim() || defaultModel;
                             setModel(chosenModel);
                             appendTranscript('Model', chosenModel);

package/dist/src/cli/index.js

@@ -8,8 +8,10 @@ import { showRunLogs } from './commands/logs.js';
 import { showJobErrors } from './commands/errors.js';
 import { exportCsv } from './commands/export.js';
 import { consumeResults } from './commands/consume.js';
+import { feedbackConsolidate, feedbackReview, feedbackSubmit } from './commands/feedback.js';
 import { showAnalytics } from './commands/analytics.js';
 import { showResults } from './commands/results.js';
+import { showPrompt, setPrompt } from './commands/prompt.js';
 import { disableStartupCommand, enableStartupCommand, installStartupCommand, startupStatusCommand, uninstallStartupCommand } from './commands/startup.js';
 import { runDoctor } from './commands/doctor.js';
 import { ensureAppDirs } from '../utils/paths.js';
@@ -38,7 +40,7 @@ function parsePositiveInteger(value) {
     return parsed;
 }
 const program = new Command();
-program.name('snoopy').description('Monitor Reddit conversations with natural language job definitions.').version(readVersion());
+program.name('snoopy').description('Monitor online conversations for high-intent signals with AI — plain language criteria, continuous scanning, zero infrastructure.').version(readVersion());
 const job = program.command('job').description('Manage monitoring jobs');
 job.command('add').description('Add a monitoring job').action(async () => {
     await addJob();
@@ -153,6 +155,89 @@ program
     .action((jobRef, options) => {
     consumeResults(jobRef, options);
 });
+const feedback = program.command('feedback').description('Collect qualification feedback and consolidate prompt improvements');
+feedback
+    .command('review')
+    .argument('[jobRef]', 'Optional job ID or slug')
+    .description('Review unvalidated qualified results and submit feedback')
+    .option('--json', 'Output raw JSON array to stdout')
+    .option('--limit <count>', 'Maximum number of results to review (default: 10)', parsePositiveInteger, 10)
+    .action(async (jobRef, options) => {
+    await feedbackReview(jobRef, options);
+});
+feedback
+    .command('submit')
+    .argument('<resultId>', 'Qualified result ID')
+    .description('Submit validity feedback for a qualified result')
+    .option('--valid', 'Mark this result as valid')
+    .option('--invalid', 'Mark this result as invalid')
+    .option('--reason <text>', 'Reason for invalid feedback (required with --invalid)')
+    .option('--json', 'Output machine-readable JSON status')
+    .action(async (resultId, options) => {
+    await feedbackSubmit(resultId, options);
+});
+feedback
+    .command('consolidate')
+    .argument('[jobRef]', 'Optional job ID or slug')
+    .description('Consolidate user feedback into improved qualification prompts')
+    .option('--limit <count>', 'Maximum pending feedback items to process', parsePositiveInteger)
+    .option('--json', 'Output machine-readable JSON status')
+    .action(async (jobRef, options) => {
+    await feedbackConsolidate(jobRef, options);
+});
+const prompt = program.command('prompt').description('View and update job qualification prompts');
+prompt
+    .argument('<jobRef>', 'Job ID or slug')
+    .description('View the qualification prompt for a specific job')
+    .option('--raw', 'Output only the prompt text and exit')
+    .action(async (jobRef, options) => {
+    await showPrompt(jobRef, options);
+});
+prompt
+    .command('set')
+    .argument('<jobRef>', 'Job ID or slug')
+    .argument('<prompt>', 'New qualification prompt text')
+    .description('Set a new qualification prompt for a specific job')
+    .action(async (jobRef, promptText) => {
+    await setPrompt(jobRef, promptText);
+});
+// --- MCP server ---
+program
+    .command('mcp')
+    .description('Start MCP server for agent integration (stdio transport)')
+    .action(async () => {
+    const { startSnoopyMcpServer } = await import('../mcp/server.js');
+    await startSnoopyMcpServer();
+});
+// --- Agent framework registration ---
+const agent = program.command('agent').description('Manage agent framework integrations');
+agent
+    .command('install')
+    .argument('<runtime>', 'Agent runtime (claude, claude-desktop, chatgpt, gemini, codex, cursor, vscode, opencode, generic-mcp)')
+    .description('Register Snoopy MCP server with an agent framework')
+    .action(async (runtime) => {
+    const { agentInstall } = await import('../agent/install.js');
+    await agentInstall(runtime);
+});
+agent
+    .command('uninstall')
+    .argument('<runtime>', 'Agent runtime')
+    .description('Remove Snoopy MCP server from an agent framework')
+    .action(async (runtime) => {
+    const { agentUninstall } = await import('../agent/install.js');
+    await agentUninstall(runtime);
+});
+agent
+    .command('status')
+    .description('Show agent framework registration status')
+    .action(async () => {
+    const { agentStatus } = await import('../agent/install.js');
+    const status = await agentStatus();
+    for (const entry of status.runtimes) {
+        const marker = entry.installed ? '✓' : '·';
+        console.log(`${marker} ${entry.runtime.padEnd(16)} ${entry.configPath}`);
+    }
+});
 program.parseAsync(process.argv).catch((error) => {
     console.error(`Error: ${String(error)}`);
     process.exit(1);

package/dist/src/mcp/helpers.d.ts

@@ -0,0 +1,46 @@
+export declare function getSnoopyVersion(): string;
+declare function formatToolError(error: unknown): {
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+    isError: true;
+};
+declare function formatToolResult(data: unknown): {
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+    structuredContent: Record<string, unknown>;
+};
+export { formatToolError, formatToolResult };
+export declare function buildDoctorReport(): Promise<Record<string, unknown>>;
+export declare function buildDaemonStatusReport(): Record<string, unknown>;
+export declare function startDaemonReport(): Record<string, unknown>;
+export declare function stopDaemonReport(): Record<string, unknown>;
+export declare function reloadDaemonReport(): Record<string, unknown>;
+export declare function listJobsReport(): Record<string, unknown>;
+export declare function listJobRunsReport(jobRef?: string, limit?: number): Record<string, unknown>;
+export declare function addJobReport(input: {
+    name: string;
+    description?: string;
+    subreddits: string[];
+    qualificationPrompt: string;
+    scheduleCron?: string;
+    enabled?: boolean;
+    monitorComments?: boolean;
+}): Record<string, unknown>;
+export declare function deleteJobReport(jobRef: string): Record<string, unknown>;
+export declare function enableJobReport(jobRef: string): Record<string, unknown>;
+export declare function disableJobReport(jobRef: string): Record<string, unknown>;
+export declare function runJobReport(jobRef: string, limit?: number): Record<string, unknown>;
+export declare function analyticsReport(jobRef?: string, days?: number): Record<string, unknown>;
+export declare function exportReport(jobRef?: string, format?: string, lastRun?: boolean, limit?: number): Record<string, unknown>;
+export declare function consumeReport(jobRef?: string, limit?: number, dryRun?: boolean): Record<string, unknown>;
+export declare function feedbackReviewReport(jobRef?: string, limit?: number): Record<string, unknown>;
+export declare function feedbackSubmitReport(resultId: string, isValid: boolean, reason?: string): Record<string, unknown>;
+export declare function feedbackConsolidateReport(jobRef?: string, limit?: number): Promise<Record<string, unknown>>;
+export declare function errorsReport(jobRef: string, hours?: number): Record<string, unknown>;
+export declare function logsReport(runId: string): Record<string, unknown>;
+export declare function settingsGetReport(): Promise<Record<string, unknown>>;
+export declare function settingsSetReport(key: string, value: string): Record<string, unknown>;