@telepat/snoopy 0.1.14 → 0.1.15

package/dist/src/services/feedback/consolidationService.js

@@ -0,0 +1,124 @@
+import { JobsRepository } from '../db/repositories/jobsRepo.js';
+import { ScanItemsRepository } from '../db/repositories/scanItemsRepo.js';
+import { SettingsRepository } from '../db/repositories/settingsRepo.js';
+import { getOpenRouterApiKey } from '../security/secretStore.js';
+import { OpenRouterClient, } from '../openrouter/client.js';
+function toFeedbackItem(row) {
+    return {
+        id: row.id,
+        type: row.type,
+        subreddit: row.subreddit,
+        title: row.title,
+        body: row.body,
+        qualificationReason: row.qualificationReason,
+        userIsValid: row.isValid,
+        userReason: row.isValidReason,
+    };
+}
+function toJobPromptResult(result) {
+    return {
+        changeSummary: result.changeSummary,
+        rationale: result.rationale,
+        promptTokens: result.promptTokens,
+        completionTokens: result.completionTokens,
+    };
+}
+export async function consolidateFeedback(options = {}) {
+    const jobsRepo = new JobsRepository();
+    const scanItemsRepo = new ScanItemsRepository();
+    let jobId;
+    if (options.jobRef) {
+        const job = jobsRepo.getByRef(options.jobRef);
+        if (!job) {
+            throw new Error(`Job not found: ${options.jobRef}`);
+        }
+        jobId = job.id;
+    }
+    const pendingRows = scanItemsRepo.listPendingFeedbackConsolidation(jobId, options.limit);
+    const totalPendingBefore = pendingRows.length;
+    if (totalPendingBefore === 0) {
+        return {
+            jobRef: options.jobRef,
+            totalPendingBefore: 0,
+            totalPendingAfter: 0,
+            totalConsolidated: 0,
+            requiresConsolidation: false,
+            jobs: [],
+        };
+    }
+    const apiKey = await getOpenRouterApiKey();
+    if (!apiKey) {
+        throw new Error('OpenRouter API key not configured. Run snoopy settings to configure it first.');
+    }
+    const settingsRepo = new SettingsRepository();
+    const appSettings = settingsRepo.getAppSettings();
+    const openRouterClient = new OpenRouterClient(apiKey);
+    const groupedByJob = new Map();
+    for (const row of pendingRows) {
+        const existing = groupedByJob.get(row.jobId) ?? [];
+        existing.push(row);
+        groupedByJob.set(row.jobId, existing);
+    }
+    const jobResults = [];
+    let totalConsolidated = 0;
+    for (const [currentJobId, rows] of groupedByJob) {
+        const job = jobsRepo.getById(currentJobId);
+        if (!job) {
+            jobResults.push({
+                jobId: currentJobId,
+                jobSlug: 'unknown',
+                jobName: 'Unknown job',
+                pendingCount: rows.length,
+                consolidatedCount: 0,
+                promptUpdated: false,
+                error: `Job no longer exists: ${currentJobId}`,
+            });
+            continue;
+        }
+        try {
+            const oldPrompt = job.qualificationPrompt;
+            const result = await openRouterClient.consolidateQualificationPrompt({
+                model: appSettings.model,
+                modelSettings: appSettings.modelSettings,
+                currentQualificationPrompt: oldPrompt,
+                feedbackItems: rows.map(toFeedbackItem),
+            });
+            const newPrompt = result.revisedQualificationPrompt;
+            jobsRepo.updateQualificationPromptById(job.id, newPrompt);
+            const consolidatedCount = scanItemsRepo.markFeedbackConsolidated(rows.map((row) => row.id));
+            totalConsolidated += consolidatedCount;
+            jobResults.push({
+                jobId: job.id,
+                jobSlug: job.slug,
+                jobName: job.name,
+                pendingCount: rows.length,
+                consolidatedCount,
+                promptUpdated: true,
+                oldPrompt,
+                newPrompt,
+                ...toJobPromptResult(result),
+            });
+        }
+        catch (error) {
+            jobResults.push({
+                jobId: job.id,
+                jobSlug: job.slug,
+                jobName: job.name,
+                pendingCount: rows.length,
+                consolidatedCount: 0,
+                promptUpdated: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    const totalPendingAfter = scanItemsRepo.countPendingFeedbackConsolidation(jobId);
+    return {
+        jobRef: options.jobRef,
+        totalPendingBefore,
+        totalPendingAfter,
+        totalConsolidated,
+        requiresConsolidation: totalPendingAfter > 0,
+        jobs: jobResults,
+    };
+}
+//# sourceMappingURL=consolidationService.js.map

package/dist/src/services/openrouter/client.d.ts

@@ -7,6 +7,23 @@ export interface QualificationResult {
     promptTokens: number;
     completionTokens: number;
 }
+export interface ConsolidationFeedbackItem {
+    id: string;
+    type: 'post' | 'comment';
+    subreddit: string;
+    title: string | null;
+    body: string;
+    qualificationReason: string | null;
+    userIsValid: boolean;
+    userReason: string | null;
+}
+export interface ConsolidatedPromptResult {
+    revisedQualificationPrompt: string;
+    changeSummary: string[];
+    rationale: string;
+    promptTokens: number;
+    completionTokens: number;
+}
 export interface OpenRouterTraceHooks {
     onRequest?: (operation: string, payload: unknown) => void;
     onResponse?: (operation: string, payload: unknown) => void;
@@ -51,6 +68,12 @@ export declare class OpenRouterClient {
         question: string;
         answer: string;
     }>, model: string): Promise<GeneratedJobSpec>;
+    consolidateQualificationPrompt(input: {
+        model: string;
+        modelSettings: ModelSettings;
+        currentQualificationPrompt: string;
+        feedbackItems: ConsolidationFeedbackItem[];
+    }): Promise<ConsolidatedPromptResult>;
     qualifyPost(input: QualifyPostRequest): Promise<QualificationResult>;
     qualifyCommentThread(input: QualifyCommentThreadRequest): Promise<QualificationResult>;
     private runQualification;

package/dist/src/services/openrouter/client.js

@@ -16,6 +16,11 @@ const qualifySchema = z.object({
     qualified: z.boolean(),
     reason: z.string().min(1).max(80)
 });
+const consolidatePromptSchema = z.object({
+    revisedQualificationPrompt: z.string().min(8),
+    changeSummary: z.array(z.string().min(1)).max(10),
+    rationale: z.string().min(1)
+});
 function toAlphaLabel(index) {
     const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
     let value = index;
@@ -241,6 +246,68 @@ export class OpenRouterClient {
             throw toOpenRouterError(error);
         }
     }
+    async consolidateQualificationPrompt(input) {
+        const feedbackJson = JSON.stringify(input.feedbackItems, null, 2);
+        const userMessage = [
+            'Current qualification prompt:',
+            input.currentQualificationPrompt,
+            '',
+            'User feedback examples (JSON):',
+            feedbackJson,
+            '',
+            'Revise by extracting general, reusable rules from feedback patterns.',
+            'Do not optimize for any single example or subreddit-specific edge case unless repeatedly supported.',
+            'Prefer consolidating with existing lines over adding many new lines.',
+            'Add a new line only when it represents a clearly distinct rule.',
+            'Return JSON with keys: revisedQualificationPrompt, changeSummary, rationale.'
+        ].join('\n');
+        const systemMessage = [
+            'You improve qualification prompts using user feedback.',
+            'Goal: make minimal but meaningful edits that improve classification quality over time.',
+            'Primary behavior: infer generally applicable decision rules, not one-off fixes.',
+            'Rules:',
+            '- Keep the revised prompt concise and practical; remove redundancy where possible.',
+            '- Generalize from repeated patterns in feedback rather than specific single examples.',
+            '- Avoid overfitting to named entities, exact wording, or one result unless it represents a broader rule.',
+            '- Preserve existing intent unless feedback clearly indicates a problem.',
+            '- Consolidate edits into existing points when semantically compatible; do not append endlessly.',
+            '- Introduce new lines only for genuinely new criteria not already covered.',
+            '- Incorporate invalid-case reasons as clear disqualifiers when they reflect reusable logic.',
+            '- Do not mention JSON, tooling, or implementation details in the revised prompt.',
+            '- Return valid JSON only with: revisedQualificationPrompt, changeSummary, rationale.'
+        ].join('\n');
+        try {
+            const payload = {
+                model: input.model,
+                temperature: input.modelSettings.temperature,
+                top_p: input.modelSettings.topP,
+                max_tokens: Math.max(600, input.modelSettings.maxTokens),
+                response_format: {
+                    type: 'json_object'
+                },
+                messages: [
+                    { role: 'system', content: systemMessage },
+                    { role: 'user', content: userMessage }
+                ]
+            };
+            this.traceRequest('chat.completions.create.consolidate_prompt', payload);
+            const completion = (await this.client.chat.completions.create(payload));
+            this.traceResponse('chat.completions.create.consolidate_prompt', completion);
+            const raw = completion.choices?.[0]?.message?.content ?? '';
+            const parsed = consolidatePromptSchema.parse(parseStructuredJson(raw));
+            return {
+                revisedQualificationPrompt: parsed.revisedQualificationPrompt,
+                changeSummary: parsed.changeSummary,
+                rationale: parsed.rationale,
+                promptTokens: completion.usage?.prompt_tokens ?? 0,
+                completionTokens: completion.usage?.completion_tokens ?? 0
+            };
+        }
+        catch (error) {
+            this.traceError('chat.completions.create.consolidate_prompt', error);
+            throw toOpenRouterError(error);
+        }
+    }
     async qualifyPost(input) {
         const userMessage = [`Post title: ${input.postTitle}`, '', `Post body: ${input.postBody}`].join('\n');
         return this.runQualification(input, userMessage);

package/dist/src/types/settings.d.ts

@@ -1,4 +1,4 @@
-export declare const DEFAULT_MODEL = "moonshotai/kimi-k2.5";
+export declare const DEFAULT_MODEL = "deepseek/deepseek-v4-pro";
 export declare const DEFAULT_CRON_INTERVAL_MINUTES = 30;
 export declare const DEFAULT_JOB_TIMEOUT_MS: number;
 export declare function intervalToCron(minutes: number): string;

package/dist/src/types/settings.js

@@ -1,4 +1,4 @@
-export const DEFAULT_MODEL = 'moonshotai/kimi-k2.5';
+export const DEFAULT_MODEL = 'deepseek/deepseek-v4-pro';
 export const DEFAULT_CRON_INTERVAL_MINUTES = 30;
 export const DEFAULT_JOB_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
 export function intervalToCron(minutes) {

package/dist/src/ui/components/MultilinePrompt.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface MultilinePromptProps {
+    label: string;
+    initialValue?: string;
+    rows?: number;
+    onSubmit: (value: string) => void;
+    onCancel: () => void;
+}
+export declare function MultilinePrompt({ label, initialValue, rows, onSubmit, onCancel, }: MultilinePromptProps): React.JSX.Element;
+export {};

package/dist/src/ui/components/MultilinePrompt.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useMemo, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { uiTheme } from '../theme.js';
+import { backspaceAtOffset, deleteAtOffset, insertAtOffset, moveCursorHorizontal, moveCursorVertical, offsetToCursor, splitLines } from './multilinePromptModel.js';
+function renderLineWithCursor(line, cursorColumn) {
+    const safeColumn = Math.max(0, Math.min(cursorColumn, line.length));
+    const before = line.slice(0, safeColumn);
+    const selectedChar = safeColumn < line.length ? line[safeColumn] : ' ';
+    const after = line.slice(safeColumn + (safeColumn < line.length ? 1 : 0));
+    return (_jsxs(Text, { color: uiTheme.ink.textPrimary, children: [before, _jsx(Text, { inverse: true, children: selectedChar }), after] }));
+}
+export function MultilinePrompt({ label, initialValue = '', rows = 8, onSubmit, onCancel, }) {
+    const [value, setValue] = useState(initialValue);
+    const [offset, setOffset] = useState(initialValue.length);
+    const [preferredColumn, setPreferredColumn] = useState(undefined);
+    const lines = useMemo(() => splitLines(value), [value]);
+    const cursor = useMemo(() => offsetToCursor(value, offset), [value, offset]);
+    const visibleRows = Math.max(3, rows);
+    const scrollTop = Math.max(0, Math.min(lines.length - visibleRows, cursor.line - Math.floor(visibleRows / 2)));
+    const visibleLines = lines.slice(scrollTop, scrollTop + visibleRows);
+    useInput((input, key) => {
+        if ((key.ctrl && input === 'c') || key.escape) {
+            onCancel();
+            return;
+        }
+        if (key.return) {
+            if (key.shift) {
+                const next = insertAtOffset(value, offset, '\n');
+                setValue(next.value);
+                setOffset(next.offset);
+                setPreferredColumn(undefined);
+                return;
+            }
+            onSubmit(value);
+            return;
+        }
+        if (key.leftArrow) {
+            setOffset((prev) => moveCursorHorizontal(value, prev, -1));
+            setPreferredColumn(undefined);
+            return;
+        }
+        if (key.rightArrow) {
+            setOffset((prev) => moveCursorHorizontal(value, prev, 1));
+            setPreferredColumn(undefined);
+            return;
+        }
+        if (key.upArrow) {
+            const moved = moveCursorVertical(value, offset, -1, preferredColumn);
+            setOffset(moved.nextOffset);
+            setPreferredColumn(moved.preferredColumn);
+            return;
+        }
+        if (key.downArrow) {
+            const moved = moveCursorVertical(value, offset, 1, preferredColumn);
+            setOffset(moved.nextOffset);
+            setPreferredColumn(moved.preferredColumn);
+            return;
+        }
+        if (key.backspace) {
+            const next = backspaceAtOffset(value, offset);
+            setValue(next.value);
+            setOffset(next.offset);
+            setPreferredColumn(undefined);
+            return;
+        }
+        if (key.delete) {
+            const next = deleteAtOffset(value, offset);
+            setValue(next.value);
+            setOffset(next.offset);
+            setPreferredColumn(undefined);
+            return;
+        }
+        if (input.length > 0 && !key.ctrl && !key.meta) {
+            const next = insertAtOffset(value, offset, input);
+            setValue(next.value);
+            setOffset(next.offset);
+            setPreferredColumn(undefined);
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: uiTheme.ink.accent, children: label }), _jsx(Box, { borderStyle: "single", borderColor: uiTheme.ink.info, paddingLeft: 1, paddingRight: 1, flexDirection: "column", children: visibleLines.map((line, index) => {
+                    const absoluteLine = scrollTop + index;
+                    const isCursorLine = absoluteLine === cursor.line;
+                    return (_jsx(React.Fragment, { children: isCursorLine ? renderLineWithCursor(line, cursor.column) : (_jsx(Text, { color: uiTheme.ink.textPrimary, children: line || ' ' })) }, `${absoluteLine}:${line}`));
+                }) }), _jsx(Text, { color: uiTheme.ink.textMuted, children: "Enter submit | Shift+Enter newline | Arrow keys move cursor | Esc cancel" })] }));
+}
+//# sourceMappingURL=MultilinePrompt.js.map

package/dist/src/ui/components/multilinePromptModel.d.ts

@@ -0,0 +1,25 @@
+export interface CursorPosition {
+    line: number;
+    column: number;
+}
+export interface VerticalMoveResult {
+    nextOffset: number;
+    preferredColumn: number;
+}
+export declare function splitLines(value: string): string[];
+export declare function offsetToCursor(value: string, offset: number): CursorPosition;
+export declare function cursorToOffset(value: string, position: CursorPosition): number;
+export declare function moveCursorHorizontal(value: string, offset: number, delta: -1 | 1): number;
+export declare function moveCursorVertical(value: string, offset: number, direction: -1 | 1, preferredColumn?: number): VerticalMoveResult;
+export declare function insertAtOffset(value: string, offset: number, inserted: string): {
+    value: string;
+    offset: number;
+};
+export declare function backspaceAtOffset(value: string, offset: number): {
+    value: string;
+    offset: number;
+};
+export declare function deleteAtOffset(value: string, offset: number): {
+    value: string;
+    offset: number;
+};

package/dist/src/ui/components/multilinePromptModel.js

@@ -0,0 +1,76 @@
+export function splitLines(value) {
+    const lines = value.split('\n');
+    return lines.length > 0 ? lines : [''];
+}
+export function offsetToCursor(value, offset) {
+    const safeOffset = Math.max(0, Math.min(offset, value.length));
+    let line = 0;
+    let column = 0;
+    for (let index = 0; index < safeOffset; index += 1) {
+        if (value[index] === '\n') {
+            line += 1;
+            column = 0;
+            continue;
+        }
+        column += 1;
+    }
+    return { line, column };
+}
+export function cursorToOffset(value, position) {
+    const lines = splitLines(value);
+    const safeLine = Math.max(0, Math.min(position.line, lines.length - 1));
+    const lineLength = lines[safeLine]?.length ?? 0;
+    const safeColumn = Math.max(0, Math.min(position.column, lineLength));
+    let offset = 0;
+    for (let index = 0; index < safeLine; index += 1) {
+        offset += (lines[index]?.length ?? 0) + 1;
+    }
+    return offset + safeColumn;
+}
+export function moveCursorHorizontal(value, offset, delta) {
+    if (delta < 0) {
+        return Math.max(0, offset - 1);
+    }
+    return Math.min(value.length, offset + 1);
+}
+export function moveCursorVertical(value, offset, direction, preferredColumn) {
+    const cursor = offsetToCursor(value, offset);
+    const lines = splitLines(value);
+    const nextLine = Math.max(0, Math.min(lines.length - 1, cursor.line + direction));
+    const targetColumn = preferredColumn ?? cursor.column;
+    const maxColumn = lines[nextLine]?.length ?? 0;
+    const nextColumn = Math.max(0, Math.min(targetColumn, maxColumn));
+    return {
+        nextOffset: cursorToOffset(value, { line: nextLine, column: nextColumn }),
+        preferredColumn: targetColumn,
+    };
+}
+export function insertAtOffset(value, offset, inserted) {
+    const safeOffset = Math.max(0, Math.min(offset, value.length));
+    const nextValue = `${value.slice(0, safeOffset)}${inserted}${value.slice(safeOffset)}`;
+    return {
+        value: nextValue,
+        offset: safeOffset + inserted.length,
+    };
+}
+export function backspaceAtOffset(value, offset) {
+    const safeOffset = Math.max(0, Math.min(offset, value.length));
+    if (safeOffset === 0) {
+        return { value, offset: safeOffset };
+    }
+    return {
+        value: `${value.slice(0, safeOffset - 1)}${value.slice(safeOffset)}`,
+        offset: safeOffset - 1,
+    };
+}
+export function deleteAtOffset(value, offset) {
+    const safeOffset = Math.max(0, Math.min(offset, value.length));
+    if (safeOffset >= value.length) {
+        return { value, offset: safeOffset };
+    }
+    return {
+        value: `${value.slice(0, safeOffset)}${value.slice(safeOffset + 1)}`,
+        offset: safeOffset,
+    };
+}
+//# sourceMappingURL=multilinePromptModel.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telepat/snoopy",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "Snoopy CLI for Reddit conversation monitoring jobs.",
   "type": "module",
   "main": "dist/src/index.js",
@@ -24,6 +24,7 @@
     "docs:build": "npm --prefix website run build",
     "docs:serve": "npm --prefix website run serve",
     "docs:deploy": "npm --prefix website run deploy",
+    "docs:write-translations": "npm --prefix website run write-translations",
     "e2e:smoke": "tsx src/scripts/e2eSmoke.ts",
     "e2e:fresh": "tsx tests/e2e/freshInstall.ts",
     "e2e:upgrade": "tsx tests/e2e/upgrade.ts",
@@ -57,6 +58,7 @@
     "better-sqlite3": "^12.8.0",
     "commander": "^14.0.3",
     "ink": "^6.8.0",
+    "jest-diff": "^29.7.0",
     "keytar": "^7.9.0",
     "node-cron": "^4.2.1",
     "node-notifier": "^10.0.1",