@telepat/snoopy 0.1.13 → 0.1.15

package/dist/src/mcp/helpers.js

@@ -0,0 +1,506 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { getDb } from '../services/db/sqlite.js';
+import { JobsRepository } from '../services/db/repositories/jobsRepo.js';
+import { RunsRepository } from '../services/db/repositories/runsRepo.js';
+import { ScanItemsRepository } from '../services/db/repositories/scanItemsRepo.js';
+import { SettingsRepository } from '../services/db/repositories/settingsRepo.js';
+import { consolidateFeedback } from '../services/feedback/consolidationService.js';
+import { AnalyticsService } from '../services/analytics/analyticsService.js';
+import { extractErrorEntries, readRunLog } from '../services/logging/logReader.js';
+import { getOpenRouterApiKey, isKeytarAvailable } from '../services/security/secretStore.js';
+import { getStartupStatus } from '../services/startup/index.js';
+import { isDaemonRunning, ensureDaemonRunning, requestDaemonReload } from '../services/daemonControl.js';
+import { ensureAppDirs } from '../utils/paths.js';
+export function getSnoopyVersion() {
+    const envVersion = process.env.npm_package_version;
+    if (envVersion) {
+        return envVersion;
+    }
+    const argvDir = process.argv[1] ? path.dirname(process.argv[1]) : process.cwd();
+    const candidates = [
+        path.resolve(process.cwd(), 'package.json'),
+        path.resolve(process.cwd(), 'snoopy/package.json'),
+        path.resolve(argvDir, '../package.json'),
+        path.resolve(argvDir, '../../package.json'),
+    ];
+    for (const candidate of candidates) {
+        try {
+            const raw = fs.readFileSync(candidate, 'utf8');
+            const pkg = JSON.parse(raw);
+            if (pkg.name === '@telepat/snoopy') {
+                return pkg.version ?? '0.0.0';
+            }
+        }
+        catch { /* try next depth */ }
+    }
+    return '0.0.0';
+}
+function formatToolError(error) {
+    const message = error instanceof Error ? error.message : String(error ?? 'Unknown error');
+    return {
+        content: [{ type: 'text', text: message }],
+        isError: true,
+    };
+}
+function formatToolResult(data) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+        structuredContent: data,
+    };
+}
+export { formatToolError, formatToolResult };
+export async function buildDoctorReport() {
+    const paths = ensureAppDirs();
+    const db = getDb();
+    let dbOk = false;
+    let dbDetails = `DB file: ${paths.dbPath}`;
+    try {
+        db.prepare('SELECT 1').get();
+        dbOk = true;
+        dbDetails = `DB reachable at ${paths.dbPath}`;
+    }
+    catch (error) {
+        dbDetails = `DB error: ${String(error)}`;
+    }
+    const jobsRepo = new JobsRepository();
+    const runsRepo = new RunsRepository();
+    const jobs = jobsRepo.list();
+    const enabledJobs = jobs.filter((j) => j.enabled).length;
+    const apiKey = await getOpenRouterApiKey();
+    const keytarAvailable = await isKeytarAvailable();
+    const startup = getStartupStatus();
+    const daemon = isDaemonRunning();
+    const recentProblemRuns = runsRepo
+        .latestWithJobNames(20)
+        .filter((run) => {
+        const timestamp = Date.parse(run.createdAt);
+        return !Number.isNaN(timestamp) && timestamp >= Date.now() - 24 * 60 * 60 * 1000;
+    })
+        .map((run) => {
+        const logContent = readRunLog(run.logFilePath);
+        const errorEntries = extractErrorEntries(logContent ?? '');
+        return { run, errorEntries };
+    })
+        .filter(({ run, errorEntries }) => run.status === 'failed' || errorEntries.length > 0);
+    return {
+        platform: process.platform,
+        nodeVersion: process.version,
+        database: { ok: dbOk, details: dbDetails },
+        openRouterApiKey: { configured: Boolean(apiKey), keytarAvailable },
+        jobs: { total: jobs.length, enabled: enabledJobs },
+        daemon: { running: daemon.running, pid: daemon.pid },
+        startup: { enabled: startup.enabled, method: startup.method, detail: startup.detail },
+        recentErrors: recentProblemRuns.map(({ run, errorEntries }) => ({
+            runId: run.id,
+            jobName: run.jobName ?? run.jobId,
+            status: run.status,
+            message: run.message,
+            errorCount: errorEntries.length,
+            latestError: errorEntries.length > 0 ? errorEntries[errorEntries.length - 1]?.split('\n')[0] : null,
+        })),
+    };
+}
+export function buildDaemonStatusReport() {
+    const status = isDaemonRunning();
+    return {
+        running: status.running,
+        pid: status.pid,
+    };
+}
+export function startDaemonReport() {
+    const result = ensureDaemonRunning();
+    return {
+        started: result.started,
+        pid: result.pid,
+    };
+}
+export function stopDaemonReport() {
+    const status = isDaemonRunning();
+    if (!status.running || !status.pid) {
+        return { stopped: false, message: 'Daemon is not running' };
+    }
+    try {
+        process.kill(status.pid, 'SIGTERM');
+        return { stopped: true, pid: status.pid };
+    }
+    catch (error) {
+        return { stopped: false, pid: status.pid, error: String(error) };
+    }
+}
+export function reloadDaemonReport() {
+    const result = requestDaemonReload();
+    return {
+        reloaded: result.reloaded,
+        pid: result.pid,
+    };
+}
+export function listJobsReport() {
+    const jobsRepo = new JobsRepository();
+    const jobs = jobsRepo.list();
+    return {
+        count: jobs.length,
+        jobs: jobs.map((j) => ({
+            id: j.id,
+            slug: j.slug,
+            name: j.name,
+            enabled: j.enabled,
+            subreddits: j.subreddits,
+            scheduleCron: j.scheduleCron,
+            monitorComments: j.monitorComments,
+        })),
+    };
+}
+export function listJobRunsReport(jobRef, limit) {
+    const runsRepo = new RunsRepository();
+    const boundedLimit = limit ?? 20;
+    if (jobRef) {
+        const jobsRepo = new JobsRepository();
+        const job = jobsRepo.getByRef(jobRef);
+        if (!job) {
+            throw new Error(`Job not found: ${jobRef}`);
+        }
+        const runs = runsRepo.listByJob(job.id, boundedLimit);
+        return {
+            job: { id: job.id, slug: job.slug, name: job.name },
+            count: runs.length,
+            runs: runs.map((r) => ({
+                id: r.id,
+                status: r.status,
+                message: r.message,
+                startedAt: r.startedAt,
+                finishedAt: r.finishedAt,
+                itemsDiscovered: r.itemsDiscovered,
+                itemsNew: r.itemsNew,
+                itemsQualified: r.itemsQualified,
+                promptTokens: r.promptTokens,
+                completionTokens: r.completionTokens,
+                estimatedCostUsd: r.estimatedCostUsd,
+            })),
+        };
+    }
+    const runs = runsRepo.latestWithJobNames(boundedLimit);
+    return {
+        count: runs.length,
+        runs: runs.map((r) => ({
+            id: r.id,
+            jobId: r.jobId,
+            jobName: r.jobName,
+            status: r.status,
+            message: r.message,
+            createdAt: r.createdAt,
+            itemsDiscovered: r.itemsDiscovered,
+            itemsNew: r.itemsNew,
+            itemsQualified: r.itemsQualified,
+        })),
+    };
+}
+export function addJobReport(input) {
+    const jobsRepo = new JobsRepository();
+    const job = jobsRepo.create({
+        name: input.name,
+        description: input.description ?? '',
+        subreddits: input.subreddits,
+        qualificationPrompt: input.qualificationPrompt,
+        scheduleCron: input.scheduleCron,
+        enabled: input.enabled,
+        monitorComments: input.monitorComments,
+    });
+    return {
+        id: job.id,
+        slug: job.slug,
+        name: job.name,
+        enabled: job.enabled,
+        subreddits: job.subreddits,
+        scheduleCron: job.scheduleCron,
+    };
+}
+export function deleteJobReport(jobRef) {
+    const jobsRepo = new JobsRepository();
+    const job = jobsRepo.removeByRef(jobRef);
+    if (!job) {
+        throw new Error(`Job not found: ${jobRef}`);
+    }
+    return { deleted: true, id: job.id, slug: job.slug, name: job.name };
+}
+export function enableJobReport(jobRef) {
+    const jobsRepo = new JobsRepository();
+    const job = jobsRepo.setEnabledByRef(jobRef, true);
+    if (!job) {
+        throw new Error(`Job not found: ${jobRef}`);
+    }
+    return { id: job.id, slug: job.slug, name: job.name, enabled: job.enabled };
+}
+export function disableJobReport(jobRef) {
+    const jobsRepo = new JobsRepository();
+    const job = jobsRepo.setEnabledByRef(jobRef, false);
+    if (!job) {
+        throw new Error(`Job not found: ${jobRef}`);
+    }
+    return { id: job.id, slug: job.slug, name: job.name, enabled: job.enabled };
+}
+export function runJobReport(jobRef, limit) {
+    const jobsRepo = new JobsRepository();
+    const job = jobsRepo.getByRef(jobRef);
+    if (!job) {
+        throw new Error(`Job not found: ${jobRef}`);
+    }
+    const args = ['job', 'run', jobRef];
+    if (limit) {
+        args.push('--limit', String(limit));
+    }
+    const result = spawnSync(process.execPath, [process.argv[1], ...args], {
+        encoding: 'utf8',
+        timeout: 120_000,
+    });
+    return {
+        job: { id: job.id, slug: job.slug, name: job.name },
+        exitCode: result.status,
+        stdout: result.stdout?.slice(0, 4000) ?? '',
+        stderr: result.stderr?.slice(0, 2000) ?? '',
+    };
+}
+export function analyticsReport(jobRef, days) {
+    const analyticsService = new AnalyticsService();
+    const boundedDays = days ?? 30;
+    if (jobRef) {
+        const jobsRepo = new JobsRepository();
+        const job = jobsRepo.getByRef(jobRef);
+        if (!job) {
+            throw new Error(`Job not found: ${jobRef}`);
+        }
+        return analyticsService.getJobAnalytics(job.id, { days: boundedDays });
+    }
+    return analyticsService.getGlobalAnalytics({ days: boundedDays });
+}
+export function exportReport(jobRef, format, lastRun, limit) {
+    const jobsRepo = new JobsRepository();
+    const scanItemsRepo = new ScanItemsRepository();
+    const runsRepo = new RunsRepository();
+    const boundedLimit = limit ?? 100;
+    const jobs = jobRef
+        ? (() => {
+            const job = jobsRepo.getByRef(jobRef);
+            if (!job)
+                throw new Error(`Job not found: ${jobRef}`);
+            return [job];
+        })()
+        : jobsRepo.list();
+    const results = [];
+    for (const job of jobs) {
+        const latestRunId = lastRun ? runsRepo.listByJob(job.id, 1)[0]?.id ?? null : null;
+        if (lastRun && !latestRunId)
+            continue;
+        const items = latestRunId
+            ? scanItemsRepo.listQualifiedByJobRun(job.id, latestRunId, boundedLimit)
+            : scanItemsRepo.listQualifiedByJob(job.id, boundedLimit);
+        results.push({
+            jobId: job.id,
+            jobSlug: job.slug,
+            jobName: job.name,
+            rowCount: items.length,
+            items,
+        });
+    }
+    return { format: format ?? 'json', jobs: results, totalRows: results.reduce((s, r) => s + r.rowCount, 0) };
+}
+export function consumeReport(jobRef, limit, dryRun) {
+    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 rows = scanItemsRepo.listUnconsumedQualified(jobId, limit);
+    if (dryRun) {
+        return { dryRun: true, count: rows.length, items: rows };
+    }
+    const consumedCount = scanItemsRepo.markConsumed(rows.map((r) => r.id));
+    return { consumed: consumedCount, items: rows };
+}
+export function feedbackReviewReport(jobRef, limit) {
+    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 boundedLimit = limit ?? 10;
+    const items = scanItemsRepo.listUnvalidatedQualified(jobId, boundedLimit);
+    return {
+        count: items.length,
+        limit: boundedLimit,
+        items,
+        workflow: {
+            nextStep: 'collect-user-feedback-and-call-snoopy_feedback_submit',
+            then: 'call-snoopy_feedback_consolidate'
+        }
+    };
+}
+export function feedbackSubmitReport(resultId, isValid, reason) {
+    const scanItemsRepo = new ScanItemsRepository();
+    const row = scanItemsRepo.getQualifiedById(resultId);
+    if (!row) {
+        throw new Error(`Qualified result not found: ${resultId}`);
+    }
+    const normalizedReason = reason?.trim() ?? '';
+    if (!isValid && normalizedReason.length === 0) {
+        throw new Error('reason is required when isValid=false');
+    }
+    const updated = scanItemsRepo.submitFeedback(resultId, isValid, isValid ? null : normalizedReason);
+    if (!updated) {
+        throw new Error(`Failed to save feedback for result: ${resultId}`);
+    }
+    const pendingFeedbackConsolidationCount = scanItemsRepo.countPendingFeedbackConsolidation(row.jobId);
+    return {
+        resultId,
+        saved: true,
+        feedback: {
+            validated: true,
+            isValid,
+            isValidReason: isValid ? null : normalizedReason,
+            feedbackConsolidated: false,
+        },
+        pendingFeedbackConsolidationCount,
+        requiresConsolidation: pendingFeedbackConsolidationCount > 0,
+        recommendedNextCommand: 'snoopy feedback consolidate',
+    };
+}
+export async function feedbackConsolidateReport(jobRef, limit) {
+    const result = await consolidateFeedback({ jobRef, limit });
+    return {
+        ...result,
+        recommendedNextAction: result.requiresConsolidation ? 'run snoopy feedback consolidate again' : 'none',
+    };
+}
+export function errorsReport(jobRef, hours) {
+    const jobsRepo = new JobsRepository();
+    const runsRepo = new RunsRepository();
+    const boundedHours = hours ?? 24;
+    const job = jobsRepo.getByRef(jobRef);
+    if (!job) {
+        throw new Error(`Job not found: ${jobRef}`);
+    }
+    const cutoff = Date.now() - boundedHours * 60 * 60 * 1000;
+    const recentRuns = runsRepo.listByJob(job.id, 100).filter((run) => {
+        const ts = Date.parse(run.createdAt);
+        return !Number.isNaN(ts) && ts >= cutoff;
+    });
+    const errorRuns = recentRuns
+        .map((run) => {
+        const logContent = readRunLog(run.logFilePath);
+        const errorEntries = extractErrorEntries(logContent ?? '');
+        return { run, errorEntries, hasErrors: run.status === 'failed' || errorEntries.length > 0 };
+    })
+        .filter((entry) => entry.hasErrors);
+    return {
+        job: { id: job.id, slug: job.slug, name: job.name },
+        hours: boundedHours,
+        errorCount: errorRuns.length,
+        errors: errorRuns.map(({ run, errorEntries }) => ({
+            runId: run.id,
+            status: run.status,
+            message: run.message,
+            createdAt: run.createdAt,
+            errorEntries: errorEntries.map((e) => e.split('\n')[0]),
+        })),
+    };
+}
+export function logsReport(runId) {
+    const runsRepo = new RunsRepository();
+    const run = runsRepo.getById(runId);
+    if (!run) {
+        throw new Error(`Run not found: ${runId}`);
+    }
+    const logContent = readRunLog(run.logFilePath);
+    return {
+        runId: run.id,
+        jobId: run.jobId,
+        jobName: run.jobName,
+        status: run.status,
+        logPath: run.logFilePath,
+        logLength: logContent?.length ?? 0,
+        log: logContent?.slice(0, 10_000) ?? null,
+    };
+}
+export async function settingsGetReport() {
+    const settingsRepo = new SettingsRepository();
+    const appSettings = settingsRepo.getAppSettings();
+    const apiKey = await getOpenRouterApiKey();
+    const redditState = await settingsRepo.getRedditCredentialState();
+    return {
+        model: appSettings.model,
+        temperature: appSettings.modelSettings.temperature,
+        maxTokens: appSettings.modelSettings.maxTokens,
+        topP: appSettings.modelSettings.topP,
+        cronIntervalMinutes: appSettings.cronIntervalMinutes,
+        jobTimeoutMs: appSettings.jobTimeoutMs,
+        notificationsEnabled: appSettings.notificationsEnabled,
+        openRouterApiKeyConfigured: Boolean(apiKey),
+        reddit: {
+            appName: redditState.appName,
+            clientId: redditState.clientId,
+            hasClientSecret: redditState.hasClientSecret,
+        },
+    };
+}
+export function settingsSetReport(key, value) {
+    const settingsRepo = new SettingsRepository();
+    const appSettings = settingsRepo.getAppSettings();
+    switch (key) {
+        case 'model':
+            appSettings.model = value;
+            break;
+        case 'temperature': {
+            const parsed = Number(value);
+            if (Number.isNaN(parsed) || parsed < 0 || parsed > 2)
+                throw new Error('temperature must be 0.0-2.0');
+            appSettings.modelSettings.temperature = parsed;
+            break;
+        }
+        case 'maxTokens': {
+            const parsed = Number(value);
+            if (!Number.isInteger(parsed) || parsed < 1)
+                throw new Error('maxTokens must be a positive integer');
+            appSettings.modelSettings.maxTokens = parsed;
+            break;
+        }
+        case 'topP': {
+            const parsed = Number(value);
+            if (Number.isNaN(parsed) || parsed < 0 || parsed > 1)
+                throw new Error('topP must be 0.0-1.0');
+            appSettings.modelSettings.topP = parsed;
+            break;
+        }
+        case 'cronIntervalMinutes': {
+            const parsed = Number(value);
+            if (!Number.isInteger(parsed) || parsed < 1)
+                throw new Error('cronIntervalMinutes must be a positive integer');
+            appSettings.cronIntervalMinutes = parsed;
+            break;
+        }
+        case 'jobTimeoutMs': {
+            const parsed = Number(value);
+            if (!Number.isInteger(parsed) || parsed < 0)
+                throw new Error('jobTimeoutMs must be a non-negative integer');
+            appSettings.jobTimeoutMs = parsed;
+            break;
+        }
+        case 'notificationsEnabled':
+            appSettings.notificationsEnabled = value === 'true';
+            break;
+        default:
+            throw new Error(`Unknown setting: ${key}`);
+    }
+    settingsRepo.setAppSettings(appSettings);
+    return { updated: key, value, settings: appSettings };
+}
+//# sourceMappingURL=helpers.js.map

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

@@ -0,0 +1 @@
+export declare function startSnoopyMcpServer(): Promise<void>;