@ttkit/daily-hot-api 0.1.3 → 0.1.4

package/dist/news-brief/news-brief.service.js

@@ -0,0 +1,676 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var NewsBriefService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewsBriefService = void 0;
+const common_1 = require("@nestjs/common");
+const crypto_1 = require("crypto");
+const cache_service_1 = require("../cache/cache.service");
+const hot_lists_service_1 = require("../host-lists/hot-lists.service");
+const hot_item_repository_1 = require("../database/repositories/hot-item.repository");
+const news_brief_repository_1 = require("../database/repositories/news-brief.repository");
+const fetch_hot_data_task_1 = require("../scheduler/tasks/fetch-hot-data.task");
+const news_category_registry_1 = require("./categories/news-category.registry");
+const news_brief_ai_client_1 = require("./clients/news-brief-ai.client");
+const news_brief_search_service_1 = require("./clients/news-brief-search.service");
+const news_brief_config_1 = require("./news-brief.config");
+const brief_date_1 = require("../daily-brief/utils/brief-date");
+const concurrency_1 = require("../daily-brief/utils/concurrency");
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const PERIOD_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
+const SEARCH_CACHE_PREFIX = 'news-brief:search:v1:';
+const SEARCH_CACHE_TTL_SECONDS = 3600;
+let NewsBriefService = NewsBriefService_1 = class NewsBriefService {
+    constructor(config, newsBriefRepository, hotItemRepository, fetchHotDataTask, hotListsService, aiClient, searchService, cacheService) {
+        this.config = config;
+        this.newsBriefRepository = newsBriefRepository;
+        this.hotItemRepository = hotItemRepository;
+        this.fetchHotDataTask = fetchHotDataTask;
+        this.hotListsService = hotListsService;
+        this.aiClient = aiClient;
+        this.searchService = searchService;
+        this.cacheService = cacheService;
+        this.logger = new common_1.Logger(NewsBriefService_1.name);
+    }
+    async generate(options = {}) {
+        const period = this.normalizePeriod(options.period);
+        const briefDate = this.resolveBriefDate(options.date);
+        const profiles = this.resolveGenerateProfiles(options.category);
+        const sourcesOverride = this.resolveSourcesOverride(options);
+        const run = {
+            freshItems: new Map(),
+            sourceNames: this.buildSourceNameMap(),
+        };
+        const results = await (0, concurrency_1.mapWithConcurrency)(profiles, this.config.categoryConcurrency, (profile) => this.generateForCategory(profile, {
+            briefDate,
+            period,
+            force: Boolean(options.force),
+            sourcesOverride,
+            run,
+        }).catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.error(`[NewsBrief] ${profile.code} generation aborted: ${message}`);
+            return {
+                category: profile.code,
+                categoryName: profile.name,
+                status: 'failed',
+                error: message,
+            };
+        }));
+        return { briefDate, period, results };
+    }
+    async findLatest(category, period, includeDebug = false) {
+        const profile = this.requireKnownCategory(category);
+        const brief = await this.newsBriefRepository.findLatest(profile.code, this.normalizePeriod(period), includeDebug);
+        return brief ? this.toResponse(brief, includeDebug) : null;
+    }
+    async findByDate(date, category, period, includeDebug = false) {
+        const profile = this.requireKnownCategory(category);
+        const brief = await this.newsBriefRepository.findByDate(this.validateDate(date), this.normalizePeriod(period), profile.code, includeDebug);
+        return brief ? this.toResponse(brief, includeDebug) : null;
+    }
+    async findDigest(categories, date, period) {
+        const profiles = this.resolveDigestProfiles(categories);
+        const briefDate = date
+            ? this.validateDate(date)
+            : (0, brief_date_1.formatBriefDate)(new Date(), this.config.timezone);
+        const normalizedPeriod = this.normalizePeriod(period);
+        const entries = await Promise.all(profiles.map(async (profile) => {
+            const brief = await this.newsBriefRepository.findByDate(briefDate, normalizedPeriod, profile.code);
+            return {
+                category: profile.code,
+                categoryName: profile.name,
+                status: brief ? brief.status : 'missing',
+                brief: brief ? this.toResponse(brief) : null,
+            };
+        }));
+        return { briefDate, categories: entries };
+    }
+    async list(options) {
+        const category = options.category
+            ? this.requireKnownCategory(options.category).code
+            : undefined;
+        const period = this.normalizePeriod(options.period);
+        return this.newsBriefRepository.list({
+            page: options.page,
+            limit: options.limit,
+            category,
+            status: options.status,
+            period,
+        });
+    }
+    async deleteByDate(date, category, period) {
+        const briefDate = this.validateDate(date);
+        if (!category) {
+            throw new common_1.BadRequestException('category is required when deleting a news brief date');
+        }
+        const profile = this.requireKnownCategory(category);
+        const normalizedPeriod = this.normalizeOptionalPeriod(period);
+        const result = await this.newsBriefRepository.deleteByDate(briefDate, profile.code, normalizedPeriod);
+        return {
+            mode: 'date',
+            briefDate,
+            category: profile.code,
+            period: normalizedPeriod ?? null,
+            deletedCount: result.deletedCount ?? 0,
+        };
+    }
+    async deleteHistory(options) {
+        if (options.olderThan && options.beforeDate) {
+            throw new common_1.BadRequestException('Use either olderThan or beforeDate, not both');
+        }
+        const beforeDate = options.beforeDate
+            ? this.validateDate(options.beforeDate)
+            : this.resolveOlderThanDate(options.olderThan);
+        const category = options.category
+            ? this.requireKnownCategory(options.category).code
+            : undefined;
+        const result = await this.newsBriefRepository.deleteBeforeDate(beforeDate, category);
+        return {
+            mode: options.beforeDate ? 'beforeDate' : 'olderThan',
+            olderThan: options.olderThan || null,
+            beforeDate,
+            category: category ?? null,
+            deletedCount: result.deletedCount ?? 0,
+        };
+    }
+    getConfig() {
+        return {
+            cronExpression: this.config.cronExpression,
+            timezone: this.config.timezone,
+            categories: this.config.categorySummaries,
+            lookbackHours: this.config.lookbackHours,
+            topItemsPerSource: this.config.topItemsPerSource,
+            maxCandidates: this.config.maxCandidates,
+            maxItemsPerCategory: this.config.maxItemsPerCategory,
+            categoryConcurrency: this.config.categoryConcurrency,
+            sourceConcurrency: this.config.sourceConcurrency,
+            generatingTimeoutMinutes: this.config.generatingTimeoutMinutes,
+            manualGenerateEnabled: this.config.manualGenerateEnabled,
+            model: this.aiClient.getModel(),
+            searchEnabled: this.config.searchEnabled,
+            searchProviders: this.config.searchProviders,
+            searchMaxQueries: this.config.searchMaxQueries,
+            searchQueryMaxChars: this.config.searchQueryMaxChars,
+        };
+    }
+    getCategories() {
+        return this.config.categorySummaries;
+    }
+    async generateForCategory(profile, params) {
+        const sources = params.sourcesOverride ?? profile.sources;
+        if (!params.force) {
+            const existing = await this.newsBriefRepository.findByDate(params.briefDate, params.period, profile.code);
+            if (existing?.status === 'success') {
+                return {
+                    category: profile.code,
+                    categoryName: profile.name,
+                    status: 'skipped',
+                    reason: 'already_generated',
+                    brief: this.toResponse(existing),
+                };
+            }
+        }
+        const generationId = (0, crypto_1.randomUUID)();
+        const timeoutMs = this.config.generatingTimeoutMinutes * 60_000;
+        const inputWindow = this.resolveInputWindow(params.briefDate, this.config.lookbackHours);
+        const claimed = await this.newsBriefRepository.claimGeneration({
+            briefDate: params.briefDate,
+            period: params.period,
+            category: profile.code,
+            categoryName: profile.name,
+            sources,
+            inputWindow,
+            model: this.aiClient.getModel(),
+            generationId,
+            staleBefore: new Date(Date.now() - timeoutMs),
+        });
+        if (!claimed) {
+            return {
+                category: profile.code,
+                categoryName: profile.name,
+                status: 'skipped',
+                reason: 'generation_in_progress',
+            };
+        }
+        const heartbeat = setInterval(() => {
+            void this.newsBriefRepository
+                .heartbeatGeneration(params.briefDate, params.period, profile.code, generationId)
+                .catch((error) => this.logger.warn('News brief heartbeat failed', error));
+        }, Math.min(60_000, Math.max(1_000, Math.floor(timeoutMs / 3))));
+        let timeout;
+        try {
+            this.logger.log(`[NewsBrief] generating ${profile.code} for ${params.briefDate}/${params.period}`);
+            const promise = this.generateClaimedBrief(profile, params.briefDate, params.period, generationId, sources, inputWindow, params.run);
+            const timedOut = new Promise((_, reject) => {
+                timeout = setTimeout(() => reject(new Error('News brief generation timed out')), timeoutMs);
+            });
+            const brief = await Promise.race([promise, timedOut]);
+            this.logger.log(`[NewsBrief] generated ${profile.code}: ${brief.itemCount} items`);
+            return {
+                category: profile.code,
+                categoryName: profile.name,
+                status: 'success',
+                brief,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.error(`[NewsBrief] failed to generate ${profile.code}: ${message}`);
+            let retained = null;
+            try {
+                const failed = await this.newsBriefRepository.markFailed(params.briefDate, params.period, profile.code, generationId, message);
+                if (failed.retained)
+                    retained = failed.brief;
+            }
+            catch (markError) {
+                this.logger.error('Failed to record news brief generation failure', markError);
+            }
+            return {
+                category: profile.code,
+                categoryName: profile.name,
+                status: 'failed',
+                error: message,
+                ...(retained
+                    ? {
+                        previousBriefRetained: true,
+                        brief: this.toResponse(retained),
+                    }
+                    : {}),
+            };
+        }
+        finally {
+            clearInterval(heartbeat);
+            if (timeout)
+                clearTimeout(timeout);
+        }
+    }
+    async generateClaimedBrief(profile, briefDate, period, generationId, sources, inputWindow, run) {
+        const [freshItems, historyItems] = await Promise.all([
+            this.fetchLatestSourceItems(sources, run),
+            this.loadHistoryItems(sources, inputWindow.start.getTime(), inputWindow.end.getTime(), run),
+        ]);
+        const inputItems = this.mergeAndLimitItems([
+            ...freshItems,
+            ...historyItems,
+        ]);
+        if (inputItems.length === 0) {
+            throw new Error('No hot items available for news brief');
+        }
+        const searchActive = this.isSearchActive(profile);
+        const searchEvidence = searchActive
+            ? await this.buildSearchEvidence(inputItems)
+            : [];
+        const searchProvidersUsed = [
+            ...new Set(searchEvidence
+                .filter((evidence) => evidence.results.length > 0)
+                .map((evidence) => evidence.provider)
+                .filter((provider) => !!provider)),
+        ];
+        const analysis = await this.aiClient.analyzeNewsBrief({
+            category: profile,
+            briefDate,
+            items: inputItems,
+            outputItemCount: this.effectiveMaxItems(profile),
+            searchEvidence,
+            contentMaxChars: searchActive
+                ? news_brief_ai_client_1.P1_CONTENT_MAX_CHARS
+                : news_brief_ai_client_1.P0_CONTENT_MAX_CHARS,
+        });
+        const saved = await this.newsBriefRepository.markSuccess(briefDate, period, profile.code, generationId, {
+            title: analysis.title,
+            summary: analysis.summary,
+            highlights: analysis.highlights,
+            items: analysis.items,
+            sources,
+            inputWindow,
+            rawInputItems: inputItems,
+            searchEvidence: searchEvidence,
+            model: this.aiClient.getModel(),
+            searchProvidersUsed,
+        });
+        if (!saved) {
+            throw new Error('News brief generation claim was lost');
+        }
+        return this.toResponse(saved);
+    }
+    async fetchLatestSourceItems(sources, run) {
+        const results = await (0, concurrency_1.mapWithConcurrency)(sources, this.config.sourceConcurrency, (source) => this.refreshSourceOnce(source, run));
+        return results.flat();
+    }
+    refreshSourceOnce(source, run) {
+        const pending = run.freshItems.get(source);
+        if (pending)
+            return pending;
+        const started = this.refreshSource(source, run.sourceNames);
+        run.freshItems.set(source, started);
+        return started;
+    }
+    async refreshSource(source, sourceNames) {
+        const topItemsPerSource = this.config.topItemsPerSource;
+        try {
+            const refreshed = await this.fetchHotDataTask.execute(source);
+            if (!refreshed.success || !refreshed.items?.length) {
+                this.logger.warn(`[NewsBrief] source ${source} contributed no fresh items: ${refreshed.error ?? 'empty result'}`);
+                return [];
+            }
+            return refreshed.items
+                .slice(0, topItemsPerSource)
+                .map((item) => this.toInputItem(source, sourceNames.get(source) ?? source, item))
+                .filter((item) => item !== null);
+        }
+        catch (error) {
+            this.logger.warn(`[NewsBrief] failed to refresh source ${source}: ${error instanceof Error ? error.message : String(error)}`);
+            return [];
+        }
+    }
+    async loadHistoryItems(sources, startTime, endTime, run) {
+        const sourceNames = run.sourceNames;
+        const topItemsPerSource = this.config.topItemsPerSource;
+        const results = await Promise.all(sources.map(async (source) => {
+            const items = await this.hotItemRepository.getDataByTimeRange(source, startTime, endTime, topItemsPerSource);
+            if (!Array.isArray(items))
+                return [];
+            return items
+                .slice(0, topItemsPerSource)
+                .map((item) => this.toInputItem(source, sourceNames.get(source) ?? source, item))
+                .filter((item) => item !== null);
+        }));
+        return results.flat();
+    }
+    buildSourceNameMap() {
+        return new Map(this.hotListsService
+            .getAllSourcesWithMetadata()
+            .map((item) => [item.name, item.title]));
+    }
+    toInputItem(source, sourceName, item) {
+        if (!item.title || !item.url)
+            return null;
+        return {
+            ref: (0, crypto_1.createHash)('sha256')
+                .update(`${source}|${item.url}`)
+                .digest('hex')
+                .slice(0, 8),
+            source,
+            sourceName,
+            title: item.title,
+            desc: item.desc,
+            hot: item.hot,
+            url: item.url,
+            timestamp: typeof item.timestamp === 'number' ? item.timestamp : undefined,
+        };
+    }
+    mergeAndLimitItems(items) {
+        const maxCandidates = this.config.maxCandidates;
+        const seen = new Set();
+        const bySource = new Map();
+        for (const item of items) {
+            if (!item.title || !item.url)
+                continue;
+            const key = `${item.source}:${item.url}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const sourceItems = bySource.get(item.source) ?? [];
+            sourceItems.push(item);
+            bySource.set(item.source, sourceItems);
+        }
+        const buckets = [...bySource.values()];
+        for (const sourceItems of buckets) {
+            sourceItems.sort((a, b) => this.timestampOf(b) - this.timestampOf(a));
+        }
+        const maxRank = buckets.reduce((longest, sourceItems) => Math.max(longest, sourceItems.length), 0);
+        const result = [];
+        for (let rank = 0; rank < maxRank; rank++) {
+            for (const sourceItems of buckets) {
+                const item = sourceItems[rank];
+                if (!item)
+                    continue;
+                result.push(item);
+                if (result.length >= maxCandidates)
+                    return result;
+            }
+        }
+        return result;
+    }
+    timestampOf(item) {
+        if (typeof item.timestamp !== 'number' ||
+            !Number.isFinite(item.timestamp)) {
+            return 0;
+        }
+        return item.timestamp < 1e12 ? item.timestamp * 1000 : item.timestamp;
+    }
+    effectiveMaxItems(profile) {
+        return Math.min(profile.maxItems, this.config.maxItemsPerCategory, news_brief_ai_client_1.PROMPT_BUDGET.maxOutputItems);
+    }
+    isSearchActive(profile) {
+        if (!this.config.searchEnabled)
+            return false;
+        if (!profile.search) {
+            this.logger.log(`[NewsBrief] category ${profile.code} opts out of search enhancement`);
+            return false;
+        }
+        if (!this.searchService.isConfigured()) {
+            this.logger.warn('[NewsBrief] search enhancement is enabled but no search provider is configured; skipping');
+            return false;
+        }
+        return true;
+    }
+    async buildSearchEvidence(inputItems) {
+        const seenTitles = new Set();
+        const candidates = inputItems
+            .filter((item) => {
+            const titleKey = item.title
+                .toLocaleLowerCase()
+                .replace(/[\s\p{P}\p{S}]+/gu, '');
+            if (!titleKey || seenTitles.has(titleKey))
+                return false;
+            seenTitles.add(titleKey);
+            return true;
+        })
+            .slice(0, Math.min(this.config.searchMaxQueries, news_brief_ai_client_1.PROMPT_BUDGET.maxSearchEvidence));
+        return (0, concurrency_1.mapWithConcurrency)(candidates, this.config.searchConcurrency, async (item) => {
+            const query = this.buildSearchQuery(item);
+            const cacheKey = `${SEARCH_CACHE_PREFIX}${(0, crypto_1.createHash)('sha256')
+                .update(`${this.config.searchProviders.join(',')}:${query}`)
+                .digest('hex')}`;
+            const cached = await this.cacheService.get(cacheKey);
+            const outcome = cached?.data ?? (await this.searchService.search(query));
+            if (!cached && outcome.results.length > 0) {
+                await this.cacheService.set(cacheKey, { data: outcome, updateTime: new Date().toISOString() }, SEARCH_CACHE_TTL_SECONDS);
+            }
+            return {
+                ref: item.ref,
+                topicTitle: item.title,
+                query,
+                provider: outcome.provider,
+                results: outcome.results,
+            };
+        });
+    }
+    buildSearchQuery(item) {
+        const base = `${item.title} ${item.desc ?? ''}`
+            .replace(/\s+/gu, ' ')
+            .trim();
+        return base.length > this.config.searchQueryMaxChars
+            ? base.slice(0, this.config.searchQueryMaxChars)
+            : base;
+    }
+    resolveDigestProfiles(raw) {
+        if (!raw)
+            return this.config.categories;
+        const codes = (Array.isArray(raw) ? raw.join(',') : raw)
+            .split(',')
+            .map((code) => code.trim())
+            .filter(Boolean);
+        if (codes.length === 0)
+            return this.config.categories;
+        const enabled = new Map(this.config.categories.map((profile) => [profile.code, profile]));
+        return [...new Set(codes)].map((code) => {
+            const known = (0, news_category_registry_1.getNewsCategoryProfile)(code);
+            if (!known) {
+                throw new common_1.BadRequestException(this.unknownCategoryMessage(code));
+            }
+            const profile = enabled.get(code);
+            if (!profile) {
+                throw new common_1.BadRequestException(`Category "${code}" is not enabled. Enabled: ${[
+                    ...enabled.keys(),
+                ].join(', ')}`);
+            }
+            return profile;
+        });
+    }
+    resolveGenerateProfiles(category) {
+        const enabled = this.config.categories;
+        if (!category)
+            return enabled;
+        const profile = enabled.find((item) => item.code === category);
+        if (!profile) {
+            const known = (0, news_category_registry_1.getNewsCategoryProfile)(category);
+            throw new common_1.BadRequestException(known
+                ? `Category "${category}" is not enabled. Enabled: ${enabled
+                    .map((item) => item.code)
+                    .join(', ')}`
+                : this.unknownCategoryMessage(category));
+        }
+        return [profile];
+    }
+    requireKnownCategory(category) {
+        if (!category) {
+            throw new common_1.BadRequestException(`category is required. Available: ${this.config.knownCategories
+                .map((item) => item.code)
+                .join(', ')}`);
+        }
+        const profile = (0, news_category_registry_1.getNewsCategoryProfile)(category);
+        if (!profile) {
+            throw new common_1.BadRequestException(this.unknownCategoryMessage(category));
+        }
+        return profile;
+    }
+    unknownCategoryMessage(category) {
+        return `Unknown category "${category}". Available: ${this.config.knownCategories
+            .map((item) => item.code)
+            .join(', ')}`;
+    }
+    resolveSourcesOverride(options) {
+        if (!options.sources || options.sources.length === 0)
+            return undefined;
+        if (!options.category) {
+            throw new common_1.BadRequestException('sources override requires an explicit category');
+        }
+        const registered = new Set(this.hotListsService.getAllSources());
+        const unknown = options.sources.filter((source) => !registered.has(source));
+        if (unknown.length > 0) {
+            throw new common_1.BadRequestException(`Unknown hot list source(s): ${unknown.join(', ')}`);
+        }
+        return [...new Set(options.sources)];
+    }
+    resolveBriefDate(date) {
+        if (!date) {
+            return (0, brief_date_1.formatBriefDate)(new Date(), this.config.timezone);
+        }
+        return this.validateDate(date);
+    }
+    validateDate(date) {
+        if (!DATE_PATTERN.test(date)) {
+            throw new common_1.BadRequestException('date must be in YYYY-MM-DD format');
+        }
+        return date;
+    }
+    normalizePeriod(period) {
+        const raw = typeof period === 'string' ? period.trim() : '';
+        const value = raw || 'daily';
+        if (!PERIOD_PATTERN.test(value)) {
+            throw new common_1.BadRequestException('period must match ^[a-z0-9][a-z0-9-]{0,31}$');
+        }
+        return value;
+    }
+    normalizeOptionalPeriod(period) {
+        const raw = typeof period === 'string' ? period.trim() : '';
+        if (!raw)
+            return undefined;
+        if (!PERIOD_PATTERN.test(raw)) {
+            throw new common_1.BadRequestException('period must match ^[a-z0-9][a-z0-9-]{0,31}$');
+        }
+        return raw;
+    }
+    resolveOlderThanDate(olderThan) {
+        if (!olderThan) {
+            throw new common_1.BadRequestException('olderThan or beforeDate is required');
+        }
+        const normalized = olderThan.trim().toLowerCase();
+        const aliases = {
+            month: '1m',
+            'one-month': '1m',
+            year: '1y',
+            'one-year': '1y',
+        };
+        const value = aliases[normalized] || normalized;
+        const match = value.match(/^(\d+)(d|day|days|m|month|months|y|year|years)$/);
+        if (!match) {
+            throw new common_1.BadRequestException('olderThan must use a value like 30d, 1m, or 1y');
+        }
+        const amount = Number(match[1]);
+        const unit = match[2];
+        const cutoff = new Date();
+        if (unit.startsWith('d')) {
+            cutoff.setDate(cutoff.getDate() - amount);
+        }
+        else if (unit.startsWith('m')) {
+            cutoff.setMonth(cutoff.getMonth() - amount);
+        }
+        else {
+            cutoff.setFullYear(cutoff.getFullYear() - amount);
+        }
+        return (0, brief_date_1.formatBriefDate)(cutoff, this.config.timezone);
+    }
+    resolveInputWindow(briefDate, lookbackHours) {
+        const now = new Date();
+        const today = (0, brief_date_1.formatBriefDate)(now, this.config.timezone);
+        const end = briefDate === today
+            ? now
+            : (0, brief_date_1.endOfBriefDate)(briefDate, this.config.timezone);
+        const start = new Date(end.getTime() - lookbackHours * 60 * 60 * 1000);
+        return { start, end, lookbackHours };
+    }
+    toResponse(brief, includeDebug = false) {
+        const items = (brief.items ?? []).map((item) => ({
+            id: item.id,
+            title: item.title,
+            summary: item.summary,
+            content: item.content,
+            source: {
+                code: item.source?.code ?? '',
+                name: item.source?.name ?? '',
+                url: item.source?.url ?? '',
+            },
+            ...(item.publishedAt ? { publishedAt: item.publishedAt } : {}),
+            ...(item.tags && item.tags.length > 0 ? { tags: item.tags } : {}),
+            ...(typeof item.importance === 'number'
+                ? { importance: item.importance }
+                : {}),
+            ...(item.extensions ? { extensions: item.extensions } : {}),
+        }));
+        const response = {
+            briefDate: brief.briefDate,
+            period: brief.period,
+            category: brief.category,
+            categoryName: brief.categoryName ?? brief.category,
+            status: brief.status,
+            ...(brief.title ? { title: brief.title } : {}),
+            ...(brief.summary ? { summary: brief.summary } : {}),
+            highlights: brief.highlights ?? [],
+            items,
+            itemCount: items.length,
+            sources: brief.sources ?? [],
+            inputWindow: brief.inputWindow
+                ? {
+                    start: new Date(brief.inputWindow.start).toISOString(),
+                    end: new Date(brief.inputWindow.end).toISOString(),
+                    lookbackHours: brief.inputWindow.lookbackHours ?? 0,
+                }
+                : {
+                    start: new Date(0).toISOString(),
+                    end: new Date(0).toISOString(),
+                    lookbackHours: 0,
+                },
+            ...(brief.model ? { model: brief.model } : {}),
+            searchProvidersUsed: brief.searchProvidersUsed ?? [],
+            ...(brief.error ? { error: brief.error } : {}),
+            ...(brief.createdAt
+                ? { createdAt: new Date(brief.createdAt).toISOString() }
+                : {}),
+            ...(brief.updatedAt
+                ? { updatedAt: new Date(brief.updatedAt).toISOString() }
+                : {}),
+        };
+        if (includeDebug) {
+            return Object.assign(response, {
+                rawInputItems: brief.rawInputItems ?? [],
+                searchEvidence: brief.searchEvidence ?? [],
+            });
+        }
+        return response;
+    }
+};
+exports.NewsBriefService = NewsBriefService;
+exports.NewsBriefService = NewsBriefService = NewsBriefService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [news_brief_config_1.NewsBriefConfigService,
+        news_brief_repository_1.NewsBriefRepository,
+        hot_item_repository_1.HotItemRepository,
+        fetch_hot_data_task_1.FetchHotDataTask,
+        hot_lists_service_1.HotListsService,
+        news_brief_ai_client_1.NewsBriefAiClient,
+        news_brief_search_service_1.NewsBriefSearchService,
+        cache_service_1.CacheService])
+], NewsBriefService);
+//# sourceMappingURL=news-brief.service.js.map