@telepat/snoopy 0.1.4 → 0.1.8

package/dist/src/services/db/repositories/jobsRepo.js

@@ -1,8 +1,6 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
-import path from 'node:path';
 import { getDb } from '../sqlite.js';
-import { getAppPaths } from '../../../utils/paths.js';
 function toSlug(value) {
     const cleaned = value
         .toLowerCase()
@@ -31,7 +29,6 @@ function mapRow(row) {
 export class JobsRepository {
     db = getDb();
     removeCascadeStmt = this.db.transaction((jobId) => {
-        const jobRow = this.db.prepare('SELECT slug FROM jobs WHERE id = ?').get(jobId);
         const runLogs = this.db
             .prepare(`SELECT log_file_path as logFilePath
          FROM job_runs
@@ -51,17 +48,6 @@ export class JobsRepository {
                 // Ignore filesystem cleanup failures and continue DB cleanup.
             }
         }
-        if (jobRow?.slug) {
-            const csvPath = path.join(getAppPaths().resultsDir, `${jobRow.slug}.csv`);
-            try {
-                if (fs.existsSync(csvPath)) {
-                    fs.unlinkSync(csvPath);
-                }
-            }
-            catch {
-                // Ignore filesystem cleanup failures and continue DB cleanup.
-            }
-        }
         this.db.prepare('DELETE FROM scan_items WHERE job_id = ?').run(jobId);
         this.db.prepare('DELETE FROM job_runs WHERE job_id = ?').run(jobId);
         this.db.prepare('DELETE FROM jobs WHERE id = ?').run(jobId);
@@ -160,5 +146,26 @@ export class JobsRepository {
         this.remove(job.id);
         return job;
     }
+    listWithStats() {
+        return this.db
+            .prepare(`SELECT
+             j.id as jobId,
+             j.slug as jobSlug,
+             j.name as jobName,
+             j.enabled as enabled,
+             j.description as description,
+             j.subreddits_json as subredditsJson,
+             j.schedule_cron as scheduleCron,
+             MAX(COALESCE(jr.finished_at, jr.started_at, jr.created_at)) as lastRunAt,
+             COALESCE(SUM(jr.items_new), 0) as totalScanned,
+             COALESCE(SUM(jr.items_qualified), 0) as totalQualified,
+             COALESCE(SUM(jr.estimated_cost_usd), 0) as totalCostUsd,
+             COUNT(jr.id) as runCount
+           FROM jobs j
+           LEFT JOIN job_runs jr ON jr.job_id = j.id
+           GROUP BY j.id
+           ORDER BY j.name ASC`)
+            .all();
+    }
 }
 //# sourceMappingURL=jobsRepo.js.map

package/dist/src/services/db/repositories/runsRepo.d.ts

@@ -10,6 +10,7 @@ export interface RunRow {
     id: string;
     jobId: string;
     jobName: string | null;
+    jobSlug: string | null;
     status: string;
     message: string | null;
     startedAt: string | null;
@@ -34,6 +35,7 @@ interface RunAnalyticsFilter {
 }
 export declare class RunsRepository {
     private readonly db;
+    private readonly runSelectWithJob;
     private buildRunFilter;
     addRun(jobId: string, status: string, message: string): void;
     startRun(jobId: string, logFilePath?: string): string;
@@ -49,6 +51,12 @@ export declare class RunsRepository {
     }>;
     listByJob(jobId: string, limit?: number): RunRow[];
     latestWithJobNames(limit?: number): RunRow[];
+    countByJob(jobId: string): number;
+    countAll(): number;
+    listByJobPage(jobId: string, limit: number, offset: number): RunRow[];
+    latestWithJobNamesPage(limit: number, offset: number): RunRow[];
+    getByJobIndex(jobId: string, index: number): RunRow | null;
+    getLatestWithJobNamesByIndex(index: number): RunRow | null;
     listAnalyticsRuns(filter: RunAnalyticsFilter): RunAnalyticsRow[];
     countRuns(filter: {
         jobId?: string;

package/dist/src/services/db/repositories/runsRepo.js

@@ -2,6 +2,25 @@ import crypto from 'node:crypto';
 import { getDb } from '../sqlite.js';
 export class RunsRepository {
     db = getDb();
+    runSelectWithJob = `SELECT
+           jr.id as id,
+           jr.job_id as jobId,
+           j.name as jobName,
+           j.slug as jobSlug,
+           jr.status as status,
+           jr.message as message,
+           jr.started_at as startedAt,
+           jr.finished_at as finishedAt,
+           jr.created_at as createdAt,
+           jr.items_discovered as itemsDiscovered,
+           jr.items_new as itemsNew,
+           jr.items_qualified as itemsQualified,
+           jr.prompt_tokens as promptTokens,
+           jr.completion_tokens as completionTokens,
+           jr.estimated_cost_usd as estimatedCostUsd,
+           jr.log_file_path as logFilePath
+         FROM job_runs jr
+         LEFT JOIN jobs j ON j.id = jr.job_id`;
     buildRunFilter(filter) {
         const params = [`-${filter.days} days`];
         const conditions = ["datetime(jr.created_at) >= datetime('now', ?)"];
@@ -66,24 +85,7 @@ export class RunsRepository {
     }
     getById(runId) {
         const row = this.db
-            .prepare(`SELECT
-           jr.id as id,
-           jr.job_id as jobId,
-           j.name as jobName,
-           jr.status as status,
-           jr.message as message,
-           jr.started_at as startedAt,
-           jr.finished_at as finishedAt,
-           jr.created_at as createdAt,
-           jr.items_discovered as itemsDiscovered,
-           jr.items_new as itemsNew,
-           jr.items_qualified as itemsQualified,
-           jr.prompt_tokens as promptTokens,
-           jr.completion_tokens as completionTokens,
-           jr.estimated_cost_usd as estimatedCostUsd,
-           jr.log_file_path as logFilePath
-         FROM job_runs jr
-         LEFT JOIN jobs j ON j.id = jr.job_id
+            .prepare(`${this.runSelectWithJob}
          WHERE jr.id = ?
          LIMIT 1`)
             .get(runId);
@@ -99,24 +101,7 @@ export class RunsRepository {
     }
     listByJob(jobId, limit = 20) {
         return this.db
-            .prepare(`SELECT
-           jr.id as id,
-           jr.job_id as jobId,
-           j.name as jobName,
-           jr.status as status,
-           jr.message as message,
-           jr.started_at as startedAt,
-           jr.finished_at as finishedAt,
-           jr.created_at as createdAt,
-           jr.items_discovered as itemsDiscovered,
-           jr.items_new as itemsNew,
-           jr.items_qualified as itemsQualified,
-           jr.prompt_tokens as promptTokens,
-           jr.completion_tokens as completionTokens,
-           jr.estimated_cost_usd as estimatedCostUsd,
-           jr.log_file_path as logFilePath
-         FROM job_runs jr
-         LEFT JOIN jobs j ON j.id = jr.job_id
+            .prepare(`${this.runSelectWithJob}
          WHERE jr.job_id = ?
          ORDER BY jr.created_at DESC
          LIMIT ?`)
@@ -124,28 +109,53 @@ export class RunsRepository {
     }
     latestWithJobNames(limit = 20) {
         return this.db
-            .prepare(`SELECT
-           jr.id as id,
-           jr.job_id as jobId,
-           j.name as jobName,
-           jr.status as status,
-           jr.message as message,
-           jr.started_at as startedAt,
-           jr.finished_at as finishedAt,
-           jr.created_at as createdAt,
-           jr.items_discovered as itemsDiscovered,
-           jr.items_new as itemsNew,
-           jr.items_qualified as itemsQualified,
-           jr.prompt_tokens as promptTokens,
-           jr.completion_tokens as completionTokens,
-           jr.estimated_cost_usd as estimatedCostUsd,
-           jr.log_file_path as logFilePath
-         FROM job_runs jr
-         LEFT JOIN jobs j ON j.id = jr.job_id
+            .prepare(`${this.runSelectWithJob}
          ORDER BY jr.created_at DESC
          LIMIT ?`)
             .all(limit);
     }
+    countByJob(jobId) {
+        const row = this.db
+            .prepare(`SELECT COUNT(*) as count
+         FROM job_runs
+         WHERE job_id = ?`)
+            .get(jobId);
+        return Number(row?.count ?? 0);
+    }
+    countAll() {
+        const row = this.db
+            .prepare(`SELECT COUNT(*) as count
+         FROM job_runs`)
+            .get();
+        return Number(row?.count ?? 0);
+    }
+    listByJobPage(jobId, limit, offset) {
+        const boundedLimit = Math.max(1, Math.floor(limit));
+        const boundedOffset = Math.max(0, Math.floor(offset));
+        return this.db
+            .prepare(`${this.runSelectWithJob}
+         WHERE jr.job_id = ?
+         ORDER BY jr.created_at DESC
+         LIMIT ? OFFSET ?`)
+            .all(jobId, boundedLimit, boundedOffset);
+    }
+    latestWithJobNamesPage(limit, offset) {
+        const boundedLimit = Math.max(1, Math.floor(limit));
+        const boundedOffset = Math.max(0, Math.floor(offset));
+        return this.db
+            .prepare(`${this.runSelectWithJob}
+         ORDER BY jr.created_at DESC
+         LIMIT ? OFFSET ?`)
+            .all(boundedLimit, boundedOffset);
+    }
+    getByJobIndex(jobId, index) {
+        const rows = this.listByJobPage(jobId, 1, index);
+        return rows[0] ?? null;
+    }
+    getLatestWithJobNamesByIndex(index) {
+        const rows = this.latestWithJobNamesPage(1, index);
+        return rows[0] ?? null;
+    }
     listAnalyticsRuns(filter) {
         const { clause, params } = this.buildRunFilter(filter);
         const limit = filter.limit ?? 20;

package/dist/src/services/db/repositories/scanItemsRepo.d.ts

@@ -19,6 +19,20 @@ export interface NewScanItem {
     completionTokens?: number;
     estimatedCostUsd?: number | null;
     qualificationReason: string | null;
+    commentThreadNodes?: NewCommentThreadNode[];
+}
+export interface NewCommentThreadNode {
+    redditCommentId: string;
+    parentRedditCommentId: string | null;
+    author: string;
+    body: string;
+    depth: number;
+    isTarget: boolean;
+}
+export interface CommentThreadNodeRow extends NewCommentThreadNode {
+    id: string;
+    scanItemId: string;
+    createdAt: string;
 }
 export interface QualifiedScanItemRow {
     id: string;
@@ -35,6 +49,29 @@ export interface QualifiedScanItemRow {
     qualificationReason: string | null;
     createdAt: string;
 }
+export interface ScanItemRow {
+    id: string;
+    jobId: string;
+    runId: string;
+    type: ScanItemType;
+    redditPostId: string;
+    redditCommentId: string | null;
+    subreddit: string;
+    author: string;
+    title: string | null;
+    body: string;
+    url: string;
+    redditPostedAt: string;
+    qualified: boolean;
+    viewed: boolean;
+    validated: boolean;
+    processed: boolean;
+    qualificationReason: string | null;
+    promptTokens: number;
+    completionTokens: number;
+    estimatedCostUsd: number | null;
+    createdAt: string;
+}
 export interface AnalyticsTotalsRow {
     newPosts: number;
     newComments: number;
@@ -56,14 +93,21 @@ interface AnalyticsFilter {
 }
 export declare class ScanItemsRepository {
     private readonly db;
+    private mapScanItemRows;
     private buildFilterClause;
     private toAnalyticsTotalsRow;
-    listQualifiedByJob(jobId: string): QualifiedScanItemRow[];
+    listQualifiedByJob(jobId: string, limit?: number): QualifiedScanItemRow[];
+    listQualifiedByJobRun(jobId: string, runId: string, limit?: number): QualifiedScanItemRow[];
+    listByJob(jobId: string): ScanItemRow[];
+    countByJob(jobId: string): number;
+    listByJobPage(jobId: string, limit: number, offset: number): ScanItemRow[];
+    getByJobIndex(jobId: string, index: number): ScanItemRow | null;
     existsPost(jobId: string, postId: string): boolean;
     getAnalyticsTotals(filter: AnalyticsFilter): AnalyticsTotalsRow;
     listAnalyticsBySubreddit(filter: AnalyticsFilter): AnalyticsBySubredditRow[];
     listAnalyticsByJob(days: number): AnalyticsByJobRow[];
     existsComment(jobId: string, postId: string, commentId: string): boolean;
     create(item: NewScanItem): string;
+    listCommentThreadNodes(scanItemId: string): CommentThreadNodeRow[];
 }
 export {};

package/dist/src/services/db/repositories/scanItemsRepo.js

@@ -2,6 +2,15 @@ import crypto from 'node:crypto';
 import { getDb } from '../sqlite.js';
 export class ScanItemsRepository {
     db = getDb();
+    mapScanItemRows(rows) {
+        return rows.map((row) => ({
+            ...row,
+            qualified: row.qualified === 1,
+            viewed: row.viewed === 1,
+            validated: row.validated === 1,
+            processed: row.processed === 1
+        }));
+    }
     buildFilterClause(alias, filter) {
         const params = [`-${filter.days} days`];
         const conditions = [`datetime(${alias}.created_at) >= datetime('now', ?)`];
@@ -23,7 +32,8 @@ export class ScanItemsRepository {
             estimatedCostUsd: Number(row.estimatedCostUsd ?? 0)
         };
     }
-    listQualifiedByJob(jobId) {
+    listQualifiedByJob(jobId, limit = 100) {
+        const boundedLimit = Math.max(1, Math.floor(limit));
         const rows = this.db
             .prepare(`SELECT
            id,
@@ -42,8 +52,9 @@ export class ScanItemsRepository {
          FROM scan_items
          WHERE job_id = ?
            AND qualified = 1
-         ORDER BY datetime(reddit_posted_at) DESC, datetime(created_at) DESC, id DESC`)
-            .all(jobId);
+         ORDER BY datetime(reddit_posted_at) DESC, datetime(created_at) DESC, id DESC
+         LIMIT ?`)
+            .all(jobId, boundedLimit);
         return rows.map((row) => ({
             ...row,
             viewed: row.viewed === 1,
@@ -51,6 +62,112 @@ export class ScanItemsRepository {
             processed: row.processed === 1
         }));
     }
+    listQualifiedByJobRun(jobId, runId, limit = 100) {
+        const boundedLimit = Math.max(1, Math.floor(limit));
+        const rows = this.db
+            .prepare(`SELECT
+           id,
+           job_id as jobId,
+           run_id as runId,
+           author,
+           title,
+           body,
+           url,
+           reddit_posted_at as redditPostedAt,
+           viewed,
+           validated,
+           processed,
+           qualification_reason as qualificationReason,
+           created_at as createdAt
+         FROM scan_items
+         WHERE job_id = ?
+           AND run_id = ?
+           AND qualified = 1
+         ORDER BY datetime(reddit_posted_at) DESC, datetime(created_at) DESC, id DESC
+         LIMIT ?`)
+            .all(jobId, runId, boundedLimit);
+        return rows.map((row) => ({
+            ...row,
+            viewed: row.viewed === 1,
+            validated: row.validated === 1,
+            processed: row.processed === 1
+        }));
+    }
+    listByJob(jobId) {
+        const rows = this.db
+            .prepare(`SELECT
+           id,
+           job_id as jobId,
+           run_id as runId,
+           type,
+           reddit_post_id as redditPostId,
+           reddit_comment_id as redditCommentId,
+           subreddit,
+           author,
+           title,
+           body,
+           url,
+           reddit_posted_at as redditPostedAt,
+           qualified,
+           viewed,
+           validated,
+           processed,
+           qualification_reason as qualificationReason,
+           prompt_tokens as promptTokens,
+           completion_tokens as completionTokens,
+           estimated_cost_usd as estimatedCostUsd,
+           created_at as createdAt
+         FROM scan_items
+         WHERE job_id = ?
+         ORDER BY datetime(reddit_posted_at) DESC, datetime(created_at) DESC, id DESC`)
+            .all(jobId);
+        return this.mapScanItemRows(rows);
+    }
+    countByJob(jobId) {
+        const row = this.db
+            .prepare(`SELECT COUNT(*) as count
+         FROM scan_items
+         WHERE job_id = ?`)
+            .get(jobId);
+        return Number(row?.count ?? 0);
+    }
+    listByJobPage(jobId, limit, offset) {
+        const boundedLimit = Math.max(1, Math.floor(limit));
+        const boundedOffset = Math.max(0, Math.floor(offset));
+        const rows = this.db
+            .prepare(`SELECT
+           id,
+           job_id as jobId,
+           run_id as runId,
+           type,
+           reddit_post_id as redditPostId,
+           reddit_comment_id as redditCommentId,
+           subreddit,
+           author,
+           title,
+           body,
+           url,
+           reddit_posted_at as redditPostedAt,
+           qualified,
+           viewed,
+           validated,
+           processed,
+           qualification_reason as qualificationReason,
+           prompt_tokens as promptTokens,
+           completion_tokens as completionTokens,
+           estimated_cost_usd as estimatedCostUsd,
+           created_at as createdAt
+         FROM scan_items
+         WHERE job_id = ?
+         ORDER BY datetime(reddit_posted_at) DESC, datetime(created_at) DESC, id DESC
+         LIMIT ? OFFSET ?`)
+            .all(jobId, boundedLimit, boundedOffset);
+        return this.mapScanItemRows(rows);
+    }
+    getByJobIndex(jobId, index) {
+        const rows = this.listByJobPage(jobId, 1, index);
+        return rows[0] ?? null;
+    }
     existsPost(jobId, postId) {
         const row = this.db
             .prepare(`SELECT 1
@@ -145,32 +262,71 @@ export class ScanItemsRepository {
     }
     create(item) {
         const id = crypto.randomUUID();
-        this.db
-            .prepare(`INSERT INTO scan_items (
-          id,
-          job_id,
-          run_id,
-          type,
-          reddit_post_id,
-          reddit_comment_id,
-          subreddit,
-          author,
-          title,
-          body,
-          url,
-          reddit_posted_at,
-          qualified,
-          viewed,
-          validated,
-          processed,
-          prompt_tokens,
-          completion_tokens,
-          estimated_cost_usd,
-          qualification_reason,
-          created_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`)
-            .run(id, item.jobId, item.runId, item.type, item.redditPostId, item.redditCommentId, item.subreddit, item.author, item.title, item.body, item.url, item.redditPostedAt, item.qualified ? 1 : 0, item.viewed ? 1 : 0, item.validated ? 1 : 0, item.processed ? 1 : 0, item.promptTokens ?? 0, item.completionTokens ?? 0, item.estimatedCostUsd ?? null, item.qualificationReason);
+        const createInTransaction = this.db.transaction((newId, newItem) => {
+            this.db
+                .prepare(`INSERT INTO scan_items (
+            id,
+            job_id,
+            run_id,
+            type,
+            reddit_post_id,
+            reddit_comment_id,
+            subreddit,
+            author,
+            title,
+            body,
+            url,
+            reddit_posted_at,
+            qualified,
+            viewed,
+            validated,
+            processed,
+            prompt_tokens,
+            completion_tokens,
+            estimated_cost_usd,
+            qualification_reason,
+            created_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`)
+                .run(newId, newItem.jobId, newItem.runId, newItem.type, newItem.redditPostId, newItem.redditCommentId, newItem.subreddit, newItem.author, newItem.title, newItem.body, newItem.url, newItem.redditPostedAt, newItem.qualified ? 1 : 0, newItem.viewed ? 1 : 0, newItem.validated ? 1 : 0, newItem.processed ? 1 : 0, newItem.promptTokens ?? 0, newItem.completionTokens ?? 0, newItem.estimatedCostUsd ?? null, newItem.qualificationReason);
+            for (const node of newItem.commentThreadNodes ?? []) {
+                this.db
+                    .prepare(`INSERT INTO comment_thread_nodes (
+              id,
+              scan_item_id,
+              reddit_comment_id,
+              parent_reddit_comment_id,
+              author,
+              body,
+              depth,
+              is_target,
+              created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`)
+                    .run(crypto.randomUUID(), newId, node.redditCommentId, node.parentRedditCommentId, node.author, node.body, node.depth, node.isTarget ? 1 : 0);
+            }
+        });
+        createInTransaction(id, item);
         return id;
     }
+    listCommentThreadNodes(scanItemId) {
+        const rows = this.db
+            .prepare(`SELECT
+           id,
+           scan_item_id as scanItemId,
+           reddit_comment_id as redditCommentId,
+           parent_reddit_comment_id as parentRedditCommentId,
+           author,
+           body,
+           depth,
+           is_target as isTarget,
+           created_at as createdAt
+         FROM comment_thread_nodes
+         WHERE scan_item_id = ?
+         ORDER BY depth ASC, created_at ASC, id ASC`)
+            .all(scanItemId);
+        return rows.map((row) => ({
+            ...row,
+            isTarget: row.isTarget === 1
+        }));
+    }
 }
 //# sourceMappingURL=scanItemsRepo.js.map

package/dist/src/services/db/sqlite.js

@@ -77,6 +77,19 @@ export function getDb() {
       FOREIGN KEY (run_id) REFERENCES job_runs(id)
     );
 
+    CREATE TABLE IF NOT EXISTS comment_thread_nodes (
+      id TEXT PRIMARY KEY,
+      scan_item_id TEXT NOT NULL,
+      reddit_comment_id TEXT NOT NULL,
+      parent_reddit_comment_id TEXT,
+      author TEXT NOT NULL,
+      body TEXT NOT NULL,
+      depth INTEGER NOT NULL,
+      is_target INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (scan_item_id) REFERENCES scan_items(id)
+    );
+
     CREATE TABLE IF NOT EXISTS daemon_state (
       id INTEGER PRIMARY KEY CHECK (id = 1),
       is_running INTEGER NOT NULL,
@@ -97,6 +110,11 @@ export function getDb() {
     }
     db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_jobs_slug ON jobs(slug)');
     db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_scan_items_dedup ON scan_items(job_id, reddit_post_id, COALESCE(reddit_comment_id, ''))");
+    db.exec('CREATE INDEX IF NOT EXISTS idx_scan_items_job_qualified_posted ON scan_items(job_id, qualified, reddit_posted_at DESC, created_at DESC)');
+    db.exec('CREATE INDEX IF NOT EXISTS idx_scan_items_job_created ON scan_items(job_id, created_at DESC)');
+    db.exec('CREATE INDEX IF NOT EXISTS idx_scan_items_created ON scan_items(created_at DESC)');
+    db.exec('CREATE INDEX IF NOT EXISTS idx_comment_thread_nodes_scan_item_depth ON comment_thread_nodes(scan_item_id, depth ASC)');
+    db.exec('CREATE INDEX IF NOT EXISTS idx_comment_thread_nodes_parent ON comment_thread_nodes(parent_reddit_comment_id)');
     try {
         db.exec('ALTER TABLE job_runs ADD COLUMN started_at TEXT');
     }

package/dist/src/services/export/csvResults.d.ts

@@ -6,5 +6,5 @@ export interface CsvExportSummary {
 }
 export declare class CsvResultsExporter {
     private readonly resultsDir;
-    exportJobResults(job: Job, qualifiedRows: QualifiedScanItemRow[]): CsvExportSummary;
+    exportJobResults(job: Job, qualifiedRows: QualifiedScanItemRow[], exportedAt?: Date): CsvExportSummary;
 }

package/dist/src/services/export/csvResults.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { getAppPaths } from '../../utils/paths.js';
+import { createExportFileName } from './fileNaming.js';
 const CSV_HEADERS = ['URL', 'Title', 'Truncated Content', 'Author', 'Justification', 'Date'];
 function truncateContent(value, maxLength) {
     if (value.length <= maxLength) {
@@ -19,8 +20,8 @@ function toCsvLine(values) {
 }
 export class CsvResultsExporter {
     resultsDir = getAppPaths().resultsDir;
-    exportJobResults(job, qualifiedRows) {
-        const outputPath = path.join(this.resultsDir, `${job.slug}.csv`);
+    exportJobResults(job, qualifiedRows, exportedAt = new Date()) {
+        const outputPath = path.join(this.resultsDir, createExportFileName(job.slug, 'csv', exportedAt));
         const lines = [toCsvLine([...CSV_HEADERS])];
         for (const row of qualifiedRows) {
             lines.push(toCsvLine([

package/dist/src/services/export/fileNaming.d.ts

@@ -0,0 +1,2 @@
+export declare function formatUtcTimestampCompact(date: Date): string;
+export declare function createExportFileName(jobSlug: string, extension: 'csv' | 'json', exportedAt?: Date): string;

package/dist/src/services/export/fileNaming.js

@@ -0,0 +1,10 @@
+function formatDatePart(value) {
+    return String(value).padStart(2, '0');
+}
+export function formatUtcTimestampCompact(date) {
+    return `${date.getUTCFullYear()}${formatDatePart(date.getUTCMonth() + 1)}${formatDatePart(date.getUTCDate())}-${formatDatePart(date.getUTCHours())}${formatDatePart(date.getUTCMinutes())}${formatDatePart(date.getUTCSeconds())}`;
+}
+export function createExportFileName(jobSlug, extension, exportedAt = new Date()) {
+    return `${formatUtcTimestampCompact(exportedAt)}_${jobSlug}.${extension}`;
+}
+//# sourceMappingURL=fileNaming.js.map

package/dist/src/services/export/jsonResults.d.ts

@@ -0,0 +1,10 @@
+import type { Job } from '../../types/job.js';
+import type { QualifiedScanItemRow } from '../db/repositories/scanItemsRepo.js';
+export interface JsonExportSummary {
+    outputPath: string;
+    rowCount: number;
+}
+export declare class JsonResultsExporter {
+    private readonly resultsDir;
+    exportJobResults(job: Job, qualifiedRows: QualifiedScanItemRow[], exportedAt?: Date): JsonExportSummary;
+}

package/dist/src/services/export/jsonResults.js

@@ -0,0 +1,16 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getAppPaths } from '../../utils/paths.js';
+import { createExportFileName } from './fileNaming.js';
+export class JsonResultsExporter {
+    resultsDir = getAppPaths().resultsDir;
+    exportJobResults(job, qualifiedRows, exportedAt = new Date()) {
+        const outputPath = path.join(this.resultsDir, createExportFileName(job.slug, 'json', exportedAt));
+        fs.writeFileSync(outputPath, `${JSON.stringify(qualifiedRows, null, 2)}\n`, 'utf8');
+        return {
+            outputPath,
+            rowCount: qualifiedRows.length
+        };
+    }
+}
+//# sourceMappingURL=jsonResults.js.map

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

@@ -23,6 +23,7 @@ interface QualifyPostRequest extends QualificationRequestBase {
 }
 interface QualifyCommentThreadRequest extends QualificationRequestBase {
     postTitle: string;
+    postBody: string;
     targetAuthor: string;
     thread: RedditComment[];
 }