@heripo/research-radar 6.0.2 → 6.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +19 -10
- package/dist/index.d.ts +65 -4
- package/dist/index.js +430 -225
- package/dist/index.js.map +1 -1
- package/package.json +4 -4
package/README.md
CHANGED
|
@@ -70,7 +70,7 @@ For academic publications:
|
|
|
70
70
|
npm install @heripo/research-radar '@llm-newsletter-kit/core@~3.1.1'
|
|
71
71
|
```
|
|
72
72
|
|
|
73
|
-
**Requirements**: Node.js 24.
|
|
73
|
+
**Requirements**: Node.js 24.22.1 or newer within 24.x, or >= 26.12.1, and an ESM application. Node.js 25 is not supported. The package exports `dist/index.js` and TypeScript declarations (`dist/index.d.ts`), with a JavaScript sourcemap. The core engine is a peer dependency; the current supported range is `~3.1.1`. Core 3.1.1 is required for recent-title guarding and source-grounded deadline extraction. It also includes the crawl-timeout retry handling and generation self-verification retry cap required by Radar.
|
|
74
74
|
|
|
75
75
|
An OpenAI API key is always required and supplies all default models. The optional compatibility path for Anthropic or Google newsletter generation additionally requires that provider's key. Keys are passed explicitly to the library; load environment variables in your application.
|
|
76
76
|
|
|
@@ -212,21 +212,30 @@ deadlines }` from a successful refresh skips extraction only if a fresh fetch
|
|
|
212
212
|
|
|
213
213
|
Pass host-selected verified actions to
|
|
214
214
|
`renderVerifiedDeadlineReminders(reminders, publicationDate)` and place its result
|
|
215
|
-
in `templateOptions.deadlineRemindersMarkdown`.
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
215
|
+
in `templateOptions.deadlineRemindersMarkdown`. Active deadlines/events from
|
|
216
|
+
D-3 through today take priority; ongoing events through a known end date fill
|
|
217
|
+
any remaining slots. Each group is ordered by date and time, with at most ten
|
|
218
|
+
entries overall (`DEADLINE_REMINDER_LEAD_DAYS`, `DEADLINE_REMINDER_LIMIT`). It preserves supplied periods and times
|
|
219
219
|
without inventing 23:59. The heading is **다가오는 일정·마감**. Today's entries say
|
|
220
220
|
**오늘 마감**, **오늘 개최** or **오늘 공개**, while ongoing events say **진행 중**.
|
|
221
221
|
An event's start time is not a cutoff: only its stated end time expires it during
|
|
222
222
|
the end date. Without an end date, it is listed only through its start date. The provider appends it to saved Markdown and HTML after
|
|
223
|
-
generation, so reminders add no
|
|
224
|
-
repeat suppression and publication history. Empty sections are omitted.
|
|
223
|
+
generation, so reminders add no article-generation context. The host owns
|
|
224
|
+
reminder scheduling, repeat suppression and publication history. Empty sections are omitted.
|
|
225
225
|
|
|
226
226
|
Prefer `templateOptions.verifiedDeadlineReminders` with freshly verified historical
|
|
227
227
|
actions. The provider merges these with source-grounded deadlines from articles
|
|
228
|
-
actually linked in the generated body
|
|
229
|
-
|
|
228
|
+
actually linked in the generated body and displays at most ten eligible
|
|
229
|
+
deadlines/events in one linked section. `generateNewsletter()` asks the
|
|
230
|
+
importance model to choose those rows from every eligible entry: it answers with
|
|
231
|
+
candidate indices only, favours actions readers can take, keeps D-1 to D-3
|
|
232
|
+
alongside today's entries and drops the same event announced by several
|
|
233
|
+
sources. Titles, dates and links are always rendered from the verified rows,
|
|
234
|
+
and an error, a 60-second timeout or an unusable answer falls back to the first
|
|
235
|
+
ten by date. A short selection is filled in date order, skipping the rows the
|
|
236
|
+
model named as duplicates. Set
|
|
237
|
+
`recentReminderCount` on a reminder to tell the selection how many issues in
|
|
238
|
+
the past week already listed it. Deduplication includes the
|
|
230
239
|
entry type, so a registration cutoff cannot replace an attendance schedule.
|
|
231
240
|
Event identity also includes the start/end dates and times, preserving separate
|
|
232
241
|
occurrences with the same title and kind. Deadline action deduplication is unchanged.
|
|
@@ -418,7 +427,7 @@ npm run format # format src/ with Prettier
|
|
|
418
427
|
npm run format:check # check src/ formatting
|
|
419
428
|
```
|
|
420
429
|
|
|
421
|
-
The build emits ESM, declarations, and a JavaScript sourcemap; runtime dependencies remain external. CI runs `npm ci`, `format:check`, `lint:ci`, `typecheck`, `npm test`, and `build` on the minimum supported Node.js
|
|
430
|
+
The build emits ESM, declarations, and a JavaScript sourcemap; runtime dependencies remain external. CI runs `npm ci`, `format:check`, `lint:ci`, `typecheck`, `npm test`, and `build` on the minimum supported versions for Node.js 24 and 26 (24.22.1 and 26.12.1), the latest 24.x, and the latest 26.x for pull requests and manual dispatch. Formatting scripts cover `src/`; to check the READMEs explicitly, run `npx prettier --check README.md README-ko.md`. `npm test` uses Node's experimental module mocking and the installed AI SDK test utilities; it makes no LLM, crawling, or email requests.
|
|
422
431
|
|
|
423
432
|
For maintainers, `release` publishes to npm, while `release:patch`, `release:minor`, and `release:major` bump the version and publish. The version hooks build first and push commits/tags; `prepublishOnly` builds before publishing.
|
|
424
433
|
|
package/dist/index.d.ts
CHANGED
|
@@ -7,8 +7,24 @@ interface VerifiedDeadlineReminder {
|
|
|
7
7
|
deadline: ArticleDeadline;
|
|
8
8
|
url: UrlString;
|
|
9
9
|
verificationStatus: 'verified';
|
|
10
|
+
/**
|
|
11
|
+
* Published issues in the past week that already listed this action.
|
|
12
|
+
* Host-supplied history; it only informs the reminder selection prompt.
|
|
13
|
+
*/
|
|
14
|
+
recentReminderCount?: number;
|
|
15
|
+
}
|
|
16
|
+
/** Days before the date an action first becomes eligible (D-3 through D-day). */
|
|
17
|
+
declare const DEADLINE_REMINDER_LEAD_DAYS = 3;
|
|
18
|
+
/** Rows the unified deadline section displays. */
|
|
19
|
+
declare const DEADLINE_REMINDER_LIMIT = 10;
|
|
20
|
+
/** A reminder that passed every display guard, with its normalized link. */
|
|
21
|
+
interface EligibleDeadlineReminder {
|
|
22
|
+
reminder: VerifiedDeadlineReminder;
|
|
23
|
+
/** Calendar days from publication to the start date; negative while ongoing. */
|
|
24
|
+
days: number;
|
|
25
|
+
url: string;
|
|
10
26
|
}
|
|
11
|
-
/** Deterministic deadlines/events, no LLM context
|
|
27
|
+
/** Deterministic deadlines/events, no LLM context: the first rows by date. */
|
|
12
28
|
declare function renderVerifiedDeadlineReminders(reminders: VerifiedDeadlineReminder[], publicationDate: IsoDateString, now?: Date): string;
|
|
13
29
|
|
|
14
30
|
/**
|
|
@@ -512,6 +528,46 @@ declare class AnalysisProvider implements AnalysisProvider$1 {
|
|
|
512
528
|
update(article: ArticleForUpdateByAnalysis): Promise<void>;
|
|
513
529
|
}
|
|
514
530
|
|
|
531
|
+
/**
|
|
532
|
+
* Chooses which eligible reminders the unified section displays.
|
|
533
|
+
*
|
|
534
|
+
* Returns a subset of the given rows in their original display order.
|
|
535
|
+
*/
|
|
536
|
+
type DeadlineReminderSelector = (rows: EligibleDeadlineReminder[], publicationDate: IsoDateString) => Promise<EligibleDeadlineReminder[]>;
|
|
537
|
+
type DeadlineReminderSelectorOptions = {
|
|
538
|
+
/** Same model that scores article importance. */
|
|
539
|
+
model: LanguageModel;
|
|
540
|
+
/**
|
|
541
|
+
* Milliseconds before the selection gives up and falls back. It runs while
|
|
542
|
+
* saving a fully generated issue, so a stalled provider must not hold it.
|
|
543
|
+
* @default 60000
|
|
544
|
+
*/
|
|
545
|
+
timeoutMs?: number;
|
|
546
|
+
/** Reports a selection that fell back to the first rows by date. */
|
|
547
|
+
onFallback?: (reason: string, candidateCount: number) => void;
|
|
548
|
+
/** Reports a model selection and its token usage. */
|
|
549
|
+
onSelected?: (info: {
|
|
550
|
+
candidateCount: number;
|
|
551
|
+
selectedCount: number;
|
|
552
|
+
/** Rows added by date order because the model chose too few. */
|
|
553
|
+
filledCount: number;
|
|
554
|
+
usage: unknown;
|
|
555
|
+
}) => void;
|
|
556
|
+
};
|
|
557
|
+
/**
|
|
558
|
+
* Builds the model selection that replaces "first rows by date".
|
|
559
|
+
*
|
|
560
|
+
* Several sources often announce the same 학술대회, and a busy day can hold
|
|
561
|
+
* fifteen same-day bids, so the earliest rows are a poor proxy for what readers
|
|
562
|
+
* need. The model judges relevance and duplicates; everything that decides
|
|
563
|
+
* whether a row may appear at all stays in {@link eligibleDeadlineReminders}.
|
|
564
|
+
*
|
|
565
|
+
* It never fails the newsletter: an error, a timeout, an empty answer or
|
|
566
|
+
* unusable indices fall back to the first rows by date. A selection shorter
|
|
567
|
+
* than the rows available is filled in date order, skipping named duplicates.
|
|
568
|
+
*/
|
|
569
|
+
declare const createDeadlineReminderSelector: (options: DeadlineReminderSelectorOptions) => DeadlineReminderSelector;
|
|
570
|
+
|
|
515
571
|
/**
|
|
516
572
|
* Content generation provider implementation
|
|
517
573
|
* - LLM-based newsletter content generation
|
|
@@ -522,6 +578,8 @@ declare class ContentGenerateProvider implements ContentGenerateProvider$1 {
|
|
|
522
578
|
private readonly articleRepository;
|
|
523
579
|
private readonly newsletterRepository;
|
|
524
580
|
private readonly templateOptions?;
|
|
581
|
+
/** Chooses displayed reminders; omitted, the first rows by date display. */
|
|
582
|
+
private readonly selectDeadlineReminders?;
|
|
525
583
|
private _issueOrder;
|
|
526
584
|
private readonly deadlineRemindersMarkdown;
|
|
527
585
|
readonly model: LanguageModel;
|
|
@@ -530,7 +588,9 @@ declare class ContentGenerateProvider implements ContentGenerateProvider$1 {
|
|
|
530
588
|
htmlTemplate: HtmlTemplate;
|
|
531
589
|
/** Newsletter brand name (defaults to config, can be overridden via constructor) */
|
|
532
590
|
newsletterBrandName: string;
|
|
533
|
-
constructor(model: LanguageModel, articleRepository: ArticleRepository, newsletterRepository: NewsletterRepository, templateOptions?: NewsletterTemplateOptions | undefined, brandName?: string
|
|
591
|
+
constructor(model: LanguageModel, articleRepository: ArticleRepository, newsletterRepository: NewsletterRepository, templateOptions?: NewsletterTemplateOptions | undefined, brandName?: string,
|
|
592
|
+
/** Chooses displayed reminders; omitted, the first rows by date display. */
|
|
593
|
+
selectDeadlineReminders?: DeadlineReminderSelector | undefined);
|
|
534
594
|
/** LLM temperature setting for content generation */
|
|
535
595
|
temperature: number;
|
|
536
596
|
/** Subscribe page URL */
|
|
@@ -565,6 +625,7 @@ declare class ContentGenerateProvider implements ContentGenerateProvider$1 {
|
|
|
565
625
|
}): Promise<{
|
|
566
626
|
id: string | number;
|
|
567
627
|
}>;
|
|
628
|
+
private renderDeadlineReminders;
|
|
568
629
|
}
|
|
569
630
|
|
|
570
631
|
type HeritageBidCandidate = {
|
|
@@ -793,5 +854,5 @@ declare function fetchResearchRadarDeadlineSource({ source, customFetch, publicD
|
|
|
793
854
|
/** Only explicit, grounded results are verified. Missing dates are never cancellation. */
|
|
794
855
|
declare function refreshResearchRadarDeadlines(config: ResearchRadarDeadlineRefreshConfig): Promise<ResearchRadarDeadlineRefreshResult>;
|
|
795
856
|
|
|
796
|
-
export { AnalysisProvider, ContentGenerateProvider, CrawlingProvider, DateService, TaskService, contentOptions, createCrawlingTargetGroups, extractResearchRadarDeadlines, fetchResearchRadarDeadlineSource, generateNewsletter, generateWelcomeHTML, getSourceList, llmConfig, maximumImportanceScoreByDomain, newsletterConfig, refreshResearchRadarDeadlines, renderVerifiedDeadlineReminders, researchRadarPromptProvider, robotsExemptOrigins };
|
|
797
|
-
export type { ArticleRepository, ContentGenerationConfig, ContentOptions, DeadlineVerificationFailure, ExcavationReport, ExcavationReportSource, NewsletterConfig, NewsletterGeneratorDependencies, NewsletterModelConfig, NewsletterRepository, NewsletterTemplateOptions, PreviewNewsletterOptions, ResearchRadarDeadlineExtractionConfig, ResearchRadarDeadlineRefreshConfig, ResearchRadarDeadlineRefreshResult, ResearchRadarDeadlineSource, ResearchRadarDeadlineSourceOptions, ResearchRadarDeadlineSourceResult, SourceGroup, SourceItem, TagRepository, TaskRepository, VerifiedDeadlineReminder, WelcomeTemplateOptions };
|
|
857
|
+
export { AnalysisProvider, ContentGenerateProvider, CrawlingProvider, DEADLINE_REMINDER_LEAD_DAYS, DEADLINE_REMINDER_LIMIT, DateService, TaskService, contentOptions, createCrawlingTargetGroups, createDeadlineReminderSelector, extractResearchRadarDeadlines, fetchResearchRadarDeadlineSource, generateNewsletter, generateWelcomeHTML, getSourceList, llmConfig, maximumImportanceScoreByDomain, newsletterConfig, refreshResearchRadarDeadlines, renderVerifiedDeadlineReminders, researchRadarPromptProvider, robotsExemptOrigins };
|
|
858
|
+
export type { ArticleRepository, ContentGenerationConfig, ContentOptions, DeadlineReminderSelector, DeadlineReminderSelectorOptions, DeadlineVerificationFailure, EligibleDeadlineReminder, ExcavationReport, ExcavationReportSource, NewsletterConfig, NewsletterGeneratorDependencies, NewsletterModelConfig, NewsletterRepository, NewsletterTemplateOptions, PreviewNewsletterOptions, ResearchRadarDeadlineExtractionConfig, ResearchRadarDeadlineRefreshConfig, ResearchRadarDeadlineRefreshResult, ResearchRadarDeadlineSource, ResearchRadarDeadlineSourceOptions, ResearchRadarDeadlineSourceResult, SourceGroup, SourceItem, TagRepository, TaskRepository, VerifiedDeadlineReminder, WelcomeTemplateOptions };
|
package/dist/index.js
CHANGED
|
@@ -200,7 +200,7 @@ function identityOf(candidate) {
|
|
|
200
200
|
candidate.classification?.trim() ?? '',
|
|
201
201
|
];
|
|
202
202
|
}
|
|
203
|
-
function buildUserPrompt(candidates) {
|
|
203
|
+
function buildUserPrompt$1(candidates) {
|
|
204
204
|
const lines = candidates.map((candidate, index) => {
|
|
205
205
|
const [institution, title, classification] = identityOf(candidate);
|
|
206
206
|
return (`${index}. [${institution}] ${title}` +
|
|
@@ -218,7 +218,7 @@ async function triageBatch(candidates, { model, onFallback }, signal) {
|
|
|
218
218
|
model,
|
|
219
219
|
output: Output.object({ schema: KEEP_SCHEMA }),
|
|
220
220
|
system: SYSTEM_PROMPT,
|
|
221
|
-
prompt: buildUserPrompt(candidates),
|
|
221
|
+
prompt: buildUserPrompt$1(candidates),
|
|
222
222
|
abortSignal: signal,
|
|
223
223
|
});
|
|
224
224
|
const verdicts = new Array(candidates.length).fill(false);
|
|
@@ -301,6 +301,402 @@ const createHeritageBidTriage = (options) => {
|
|
|
301
301
|
};
|
|
302
302
|
};
|
|
303
303
|
|
|
304
|
+
/**
|
|
305
|
+
* Date service implementation
|
|
306
|
+
* - Provides newsletter publication date strings (ISO and localized display form)
|
|
307
|
+
* - Always returns Korea Standard Time (KST, Asia/Seoul) regardless of server timezone
|
|
308
|
+
* - Accepts optional publishDate to override "today" (e.g., generating today's run for tomorrow's publication)
|
|
309
|
+
*/
|
|
310
|
+
class DateService {
|
|
311
|
+
targetDate;
|
|
312
|
+
/**
|
|
313
|
+
* @param publishDate - Optional ISO date string (YYYY-MM-DD) representing the newsletter
|
|
314
|
+
* publication date. If omitted, the current wall-clock time (KST)
|
|
315
|
+
* is used. Pass tomorrow's date when building the issue the night before.
|
|
316
|
+
* @throws {Error} If publishDate is not in YYYY-MM-DD format or is not a real calendar date.
|
|
317
|
+
*/
|
|
318
|
+
constructor(publishDate) {
|
|
319
|
+
if (publishDate !== undefined) {
|
|
320
|
+
if (!/^\d{4}-\d{2}-\d{2}$/.test(publishDate)) {
|
|
321
|
+
throw new Error(`Invalid publishDate format: "${publishDate}". Expected YYYY-MM-DD (e.g., "2025-02-12").`);
|
|
322
|
+
}
|
|
323
|
+
const date = new Date(publishDate + 'T00:00:00+09:00');
|
|
324
|
+
// Round-trip check: format back to YYYY-MM-DD in KST and compare.
|
|
325
|
+
// Catches invalid dates like "2025-02-30" that JS silently normalizes to "2025-03-02".
|
|
326
|
+
const roundTrip = date.toLocaleDateString('en-CA', {
|
|
327
|
+
timeZone: 'Asia/Seoul',
|
|
328
|
+
});
|
|
329
|
+
if (roundTrip !== publishDate) {
|
|
330
|
+
throw new Error(`Invalid publishDate: "${publishDate}" is not a real calendar date.`);
|
|
331
|
+
}
|
|
332
|
+
this.targetDate = date;
|
|
333
|
+
}
|
|
334
|
+
else {
|
|
335
|
+
this.targetDate = new Date();
|
|
336
|
+
}
|
|
337
|
+
}
|
|
338
|
+
/**
|
|
339
|
+
* Get the newsletter publication date in ISO format (YYYY-MM-DD).
|
|
340
|
+
* - Always returns date in Korea Standard Time (UTC+9)
|
|
341
|
+
* @returns ISO date string (e.g., "2024-10-15")
|
|
342
|
+
*/
|
|
343
|
+
getPublicationISODateString() {
|
|
344
|
+
// Use Intl.DateTimeFormat to get date in Korea timezone
|
|
345
|
+
// 'en-CA' locale returns YYYY-MM-DD format by default
|
|
346
|
+
const kstDate = this.targetDate.toLocaleDateString('en-CA', {
|
|
347
|
+
timeZone: 'Asia/Seoul',
|
|
348
|
+
});
|
|
349
|
+
return kstDate;
|
|
350
|
+
}
|
|
351
|
+
getCurrentISODateString() {
|
|
352
|
+
return this.getPublicationISODateString();
|
|
353
|
+
}
|
|
354
|
+
/**
|
|
355
|
+
* Get the newsletter publication date as a localized display string.
|
|
356
|
+
* - Always returns date in Korea Standard Time (UTC+9)
|
|
357
|
+
* @returns Korean formatted date (e.g., "2024년 10월 15일")
|
|
358
|
+
*/
|
|
359
|
+
getPublicationDisplayDateString() {
|
|
360
|
+
const formatter = new Intl.DateTimeFormat('ko-KR', {
|
|
361
|
+
timeZone: 'Asia/Seoul',
|
|
362
|
+
year: 'numeric',
|
|
363
|
+
month: 'long',
|
|
364
|
+
day: 'numeric',
|
|
365
|
+
});
|
|
366
|
+
return formatter.format(this.targetDate);
|
|
367
|
+
}
|
|
368
|
+
getDisplayDateString() {
|
|
369
|
+
return this.getPublicationDisplayDateString();
|
|
370
|
+
}
|
|
371
|
+
}
|
|
372
|
+
|
|
373
|
+
/** Days before the date an action first becomes eligible (D-3 through D-day). */
|
|
374
|
+
const DEADLINE_REMINDER_LEAD_DAYS = 3;
|
|
375
|
+
/** Rows the unified deadline section displays. */
|
|
376
|
+
const DEADLINE_REMINDER_LIMIT = 10;
|
|
377
|
+
function escapeLabel(value) {
|
|
378
|
+
return value
|
|
379
|
+
.replace(/\s+/g, ' ')
|
|
380
|
+
.replace(/&/g, '&')
|
|
381
|
+
.replace(/</g, '<')
|
|
382
|
+
.replace(/>/g, '>')
|
|
383
|
+
.replace(/[\\`*_{}[\]()|!#]/g, '\\$&');
|
|
384
|
+
}
|
|
385
|
+
const clockPattern = /^(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d)?$/;
|
|
386
|
+
const fullClock = (time) => (time.length === 5 ? `${time}:00` : time);
|
|
387
|
+
function calendarMs(date) {
|
|
388
|
+
if (!/^\d{4}-\d{2}-\d{2}$/.test(date))
|
|
389
|
+
return NaN;
|
|
390
|
+
const ms = Date.parse(`${date}T00:00:00Z`);
|
|
391
|
+
return Number.isFinite(ms) && new Date(ms).toISOString().slice(0, 10) === date
|
|
392
|
+
? ms
|
|
393
|
+
: NaN;
|
|
394
|
+
}
|
|
395
|
+
/**
|
|
396
|
+
* Every displayable reminder, deduplicated and in display order.
|
|
397
|
+
*
|
|
398
|
+
* Eligibility stays deterministic: only verified, active actions from D-3
|
|
399
|
+
* through D-day, or events still running, with a safe link and a closing time
|
|
400
|
+
* that has not passed. Selection may choose among these but never adds to them.
|
|
401
|
+
*/
|
|
402
|
+
function eligibleDeadlineReminders(reminders, publicationDate, now = new Date()) {
|
|
403
|
+
const date = new DateService(publicationDate).getPublicationISODateString();
|
|
404
|
+
const publicationMs = Date.parse(`${date}T00:00:00Z`);
|
|
405
|
+
const rows = reminders
|
|
406
|
+
.flatMap((reminder) => {
|
|
407
|
+
const { deadline } = reminder;
|
|
408
|
+
if (reminder.verificationStatus !== 'verified' ||
|
|
409
|
+
deadline.status !== 'active' ||
|
|
410
|
+
!deadline.date ||
|
|
411
|
+
!/^\d{4}-\d{2}-\d{2}$/.test(deadline.date))
|
|
412
|
+
return [];
|
|
413
|
+
const isEvent = deadline.type === 'event';
|
|
414
|
+
const ms = calendarMs(deadline.date);
|
|
415
|
+
const endDate = isEvent
|
|
416
|
+
? (deadline.endDate ?? deadline.date)
|
|
417
|
+
: deadline.date;
|
|
418
|
+
const endMs = calendarMs(endDate);
|
|
419
|
+
if (!Number.isFinite(ms) || !Number.isFinite(endMs) || endMs < ms)
|
|
420
|
+
return [];
|
|
421
|
+
if ((!isEvent && (deadline.endDate || deadline.endTime)) ||
|
|
422
|
+
(deadline.endTime && !deadline.endDate))
|
|
423
|
+
return [];
|
|
424
|
+
if ((deadline.time && !clockPattern.test(deadline.time)) ||
|
|
425
|
+
(deadline.endTime && !clockPattern.test(deadline.endTime)))
|
|
426
|
+
return [];
|
|
427
|
+
if (isEvent &&
|
|
428
|
+
endDate === deadline.date &&
|
|
429
|
+
deadline.time &&
|
|
430
|
+
deadline.endTime &&
|
|
431
|
+
fullClock(deadline.endTime) < fullClock(deadline.time))
|
|
432
|
+
return [];
|
|
433
|
+
const days = (ms - publicationMs) / 86_400_000;
|
|
434
|
+
// Events remain eligible through a known end date; a start time is never
|
|
435
|
+
// treated as an application cutoff. Unknown endpoints stay unknown.
|
|
436
|
+
if (days > DEADLINE_REMINDER_LEAD_DAYS ||
|
|
437
|
+
endMs < publicationMs ||
|
|
438
|
+
!deadline.title.trim())
|
|
439
|
+
return [];
|
|
440
|
+
let url;
|
|
441
|
+
try {
|
|
442
|
+
url = new URL(reminder.url);
|
|
443
|
+
if (!['http:', 'https:'].includes(url.protocol) ||
|
|
444
|
+
url.username ||
|
|
445
|
+
url.password)
|
|
446
|
+
return [];
|
|
447
|
+
if (deadline.timeZone)
|
|
448
|
+
new Intl.DateTimeFormat('en', { timeZone: deadline.timeZone });
|
|
449
|
+
const closingTime = isEvent ? deadline.endTime : deadline.time;
|
|
450
|
+
if (closingTime) {
|
|
451
|
+
const parts = new Intl.DateTimeFormat('en', {
|
|
452
|
+
timeZone: deadline.timeZone ?? 'Asia/Seoul',
|
|
453
|
+
year: 'numeric',
|
|
454
|
+
month: '2-digit',
|
|
455
|
+
day: '2-digit',
|
|
456
|
+
hour: '2-digit',
|
|
457
|
+
minute: '2-digit',
|
|
458
|
+
second: '2-digit',
|
|
459
|
+
hourCycle: 'h23',
|
|
460
|
+
}).formatToParts(now);
|
|
461
|
+
const values = Object.fromEntries(parts.map(({ type, value }) => [type, value]));
|
|
462
|
+
const localNow = `${values.year}-${values.month}-${values.day} ${values.hour}:${values.minute}:${values.second}`;
|
|
463
|
+
const closes = `${endDate} ${fullClock(closingTime)}`;
|
|
464
|
+
if (closes <= localNow)
|
|
465
|
+
return [];
|
|
466
|
+
}
|
|
467
|
+
}
|
|
468
|
+
catch {
|
|
469
|
+
return [];
|
|
470
|
+
}
|
|
471
|
+
return [
|
|
472
|
+
{
|
|
473
|
+
reminder,
|
|
474
|
+
days,
|
|
475
|
+
ms,
|
|
476
|
+
url: url.href.replace(/[()]/g, (value) => encodeURIComponent(value)),
|
|
477
|
+
},
|
|
478
|
+
];
|
|
479
|
+
})
|
|
480
|
+
.sort((a, b) =>
|
|
481
|
+
// The fallback limit must not let older ongoing events displace
|
|
482
|
+
// today's or upcoming deadlines/events. Ongoing events fill spare rows.
|
|
483
|
+
Number(a.days < 0) - Number(b.days < 0) ||
|
|
484
|
+
a.ms - b.ms ||
|
|
485
|
+
(a.reminder.deadline.time ?? '23:59:59').localeCompare(b.reminder.deadline.time ?? '23:59:59'));
|
|
486
|
+
const seen = new Set();
|
|
487
|
+
return rows.flatMap(({ reminder, days, url }) => {
|
|
488
|
+
const d = reminder.deadline;
|
|
489
|
+
const key = JSON.stringify([
|
|
490
|
+
url,
|
|
491
|
+
d.type ?? 'deadline',
|
|
492
|
+
d.title,
|
|
493
|
+
d.kind,
|
|
494
|
+
d.date,
|
|
495
|
+
d.time,
|
|
496
|
+
d.endDate ?? null,
|
|
497
|
+
d.endTime ?? null,
|
|
498
|
+
]);
|
|
499
|
+
if (seen.has(key))
|
|
500
|
+
return [];
|
|
501
|
+
seen.add(key);
|
|
502
|
+
return [{ reminder, days, url }];
|
|
503
|
+
});
|
|
504
|
+
}
|
|
505
|
+
/** Renders already eligible rows in the order given, up to the display limit. */
|
|
506
|
+
function formatDeadlineReminders(rows) {
|
|
507
|
+
const lines = rows
|
|
508
|
+
.slice(0, DEADLINE_REMINDER_LIMIT)
|
|
509
|
+
.map(({ reminder, days, url }) => {
|
|
510
|
+
const d = reminder.deadline;
|
|
511
|
+
const isEvent = d.type === 'event';
|
|
512
|
+
const time = d.time ? ` ${d.time}` : '';
|
|
513
|
+
const end = isEvent && d.endDate
|
|
514
|
+
? d.endDate !== d.date
|
|
515
|
+
? ` ~ ${d.endDate}${d.endTime ? ` ${d.endTime}` : ''}`
|
|
516
|
+
: d.endTime
|
|
517
|
+
? ` ~ ${d.endTime}`
|
|
518
|
+
: ''
|
|
519
|
+
: '';
|
|
520
|
+
const zone = (d.time || (isEvent && d.endTime)) && d.timeZone
|
|
521
|
+
? ` (${escapeLabel(d.timeZone)})`
|
|
522
|
+
: '';
|
|
523
|
+
const timing = days > 0
|
|
524
|
+
? `D-${days}`
|
|
525
|
+
: days < 0
|
|
526
|
+
? '진행 중'
|
|
527
|
+
: isEvent
|
|
528
|
+
? /공개/.test(d.kind)
|
|
529
|
+
? '오늘 공개'
|
|
530
|
+
: '오늘 개최'
|
|
531
|
+
: '오늘 마감';
|
|
532
|
+
const label = d.title.includes(d.kind)
|
|
533
|
+
? d.title
|
|
534
|
+
: `${d.title} · ${d.kind}`;
|
|
535
|
+
return `| [${escapeLabel(label)}](${url}) | **${d.date}${time}${end}${zone} · ${timing}** |`;
|
|
536
|
+
});
|
|
537
|
+
return lines.length
|
|
538
|
+
? `## ⏰ 다가오는 일정·마감\n\n| 안내 | 일정 |\n| --- | --- |\n${lines.join('\n')}`
|
|
539
|
+
: '';
|
|
540
|
+
}
|
|
541
|
+
/** Deterministic deadlines/events, no LLM context: the first rows by date. */
|
|
542
|
+
function renderVerifiedDeadlineReminders(reminders, publicationDate, now = new Date()) {
|
|
543
|
+
return formatDeadlineReminders(eligibleDeadlineReminders(reminders, publicationDate, now));
|
|
544
|
+
}
|
|
545
|
+
|
|
546
|
+
/**
|
|
547
|
+
* Asks for the indices to display, never for titles, dates or links.
|
|
548
|
+
*
|
|
549
|
+
* Rendering stays on the verified rows, so the model can only leave a row out;
|
|
550
|
+
* it cannot invent an action or alter one. Indices out of range or repeated
|
|
551
|
+
* are discarded rather than trusted. Duplicates are named separately so a short
|
|
552
|
+
* selection can be filled without restoring an event the model merged.
|
|
553
|
+
*/
|
|
554
|
+
const SELECT_SCHEMA = jsonSchema({
|
|
555
|
+
type: 'object',
|
|
556
|
+
properties: {
|
|
557
|
+
select: {
|
|
558
|
+
type: 'array',
|
|
559
|
+
items: { type: 'integer' },
|
|
560
|
+
description: '뉴스레터에 안내할 일정·마감 후보의 번호',
|
|
561
|
+
},
|
|
562
|
+
duplicates: {
|
|
563
|
+
type: 'array',
|
|
564
|
+
items: { type: 'integer' },
|
|
565
|
+
description: '고른 후보와 같은 행사·마감이라 뺀 후보의 번호',
|
|
566
|
+
},
|
|
567
|
+
},
|
|
568
|
+
required: ['select', 'duplicates'],
|
|
569
|
+
additionalProperties: false,
|
|
570
|
+
});
|
|
571
|
+
const systemPrompt = (limit) => `너는 한국 고고학·문화유산 뉴스레터의 "다가오는 일정·마감" 안내를 고른다.
|
|
572
|
+
|
|
573
|
+
독자는 고고학·문화유산 연구자, 발굴·조사기관 종사자, 학예 인력, 관련 전공 학생이다.
|
|
574
|
+
후보는 모두 원문에서 다시 확인한 일정이다. 날짜·제목은 바꿀 수 없고, 너는 번호만 고른다.
|
|
575
|
+
|
|
576
|
+
고르는 규칙:
|
|
577
|
+
- 최대 ${limit}개를 고른다. 같은 행사 중복을 빼고도 후보가 ${limit}개 이상 남으면 반드시 ${limit}개를 채운다.
|
|
578
|
+
- 같은 행사 중복을 뺀 후보가 ${limit}개 미만이면 중복만 빼고 모두 고른다. 후순위 일정도 자리가 남으면 뺄 이유가 없다.
|
|
579
|
+
- 같은 행사나 같은 마감을 가리키는 후보는 하나만 고르고, 나머지 번호는 duplicates에 넣는다. 게시 기관이 달라 제목 표현이 조금 달라도 날짜·시각과 내용이 같으면 같은 행사다.
|
|
580
|
+
- 시각이 다른 회차, 링크의 공고번호가 다른 공고는 제목이 같아도 서로 다른 일정이다. duplicates에 넣지 않는다.
|
|
581
|
+
- 독자가 행동할 수 있는 일정을 우선한다: 학술대회·발표·논문 신청, 공모·지원사업 신청, 채용 접수, 발굴 현장 공개, 발굴·시굴·지표조사와 국가유산 수리·보존처리 입찰, 강연·답사 참가 신청.
|
|
582
|
+
- 문화유산과 관련이 약한 일반 시설·장비·전산 입찰, 행사 운영 대행은 후순위로 둔다.
|
|
583
|
+
- 오늘 마감·개최는 마지막 기회이므로 중요한 것을 우선 포함한다. 다만 오늘 일정만으로 채우지 말고 D-1~D-3 일정도 고르게 포함해 독자가 미리 준비할 수 있게 한다.
|
|
584
|
+
- "진행 중"인 장기 전시·행사는 남는 자리에만 넣는다. 최근 여러 번 안내된 일정은 더 뒤로 미룬다.
|
|
585
|
+
- 번호의 순서는 상관없다. 표시 순서는 날짜순으로 따로 정해진다.`;
|
|
586
|
+
function timingOf({ days, reminder }) {
|
|
587
|
+
if (days > 0)
|
|
588
|
+
return `D-${days}`;
|
|
589
|
+
if (days < 0)
|
|
590
|
+
return '진행 중';
|
|
591
|
+
return reminder.deadline.type === 'event' ? '오늘 개최' : '오늘 마감';
|
|
592
|
+
}
|
|
593
|
+
function clockOf(date, time) {
|
|
594
|
+
return time ? `${date} ${time}` : date;
|
|
595
|
+
}
|
|
596
|
+
function buildUserPrompt(rows, publicationDate, limit) {
|
|
597
|
+
const lines = rows.map((row, index) => {
|
|
598
|
+
const { deadline, recentReminderCount } = row.reminder;
|
|
599
|
+
const start = clockOf(deadline.date, deadline.time);
|
|
600
|
+
const end = deadline.type === 'event' && deadline.endDate
|
|
601
|
+
? deadline.endDate !== deadline.date
|
|
602
|
+
? ` ~ ${clockOf(deadline.endDate, deadline.endTime)}`
|
|
603
|
+
: deadline.endTime
|
|
604
|
+
? ` ~ ${deadline.endTime}`
|
|
605
|
+
: ''
|
|
606
|
+
: '';
|
|
607
|
+
const zone = deadline.timeZone ? ` (${deadline.timeZone})` : '';
|
|
608
|
+
const recent = recentReminderCount
|
|
609
|
+
? ` · 최근 7일 ${recentReminderCount}회 안내`
|
|
610
|
+
: '';
|
|
611
|
+
// The full link carries notice numbers, which tell same-titled bids apart.
|
|
612
|
+
return `${index}. [${timingOf(row)}] ${start}${end}${zone} · ${deadline.type === 'event' ? '행사' : '마감'} · ${deadline.kind} · ${deadline.title.replace(/\s+/g, ' ')} · ${row.url}${recent}`;
|
|
613
|
+
});
|
|
614
|
+
return `발행일 ${publicationDate}. 다음 ${rows.length}건 중 안내할 일정을 최대 ${limit}개 골라 번호로 답하라.\n\n${lines.join('\n')}`;
|
|
615
|
+
}
|
|
616
|
+
/**
|
|
617
|
+
* Builds the model selection that replaces "first rows by date".
|
|
618
|
+
*
|
|
619
|
+
* Several sources often announce the same 학술대회, and a busy day can hold
|
|
620
|
+
* fifteen same-day bids, so the earliest rows are a poor proxy for what readers
|
|
621
|
+
* need. The model judges relevance and duplicates; everything that decides
|
|
622
|
+
* whether a row may appear at all stays in {@link eligibleDeadlineReminders}.
|
|
623
|
+
*
|
|
624
|
+
* It never fails the newsletter: an error, a timeout, an empty answer or
|
|
625
|
+
* unusable indices fall back to the first rows by date. A selection shorter
|
|
626
|
+
* than the rows available is filled in date order, skipping named duplicates.
|
|
627
|
+
*/
|
|
628
|
+
const createDeadlineReminderSelector = (options) => {
|
|
629
|
+
const limit = DEADLINE_REMINDER_LIMIT;
|
|
630
|
+
const fallback = (rows, reason) => {
|
|
631
|
+
options.onFallback?.(reason, rows.length);
|
|
632
|
+
return rows.slice(0, limit);
|
|
633
|
+
};
|
|
634
|
+
return async (rows, publicationDate) => {
|
|
635
|
+
// One row leaves nothing to choose or deduplicate.
|
|
636
|
+
if (rows.length <= 1)
|
|
637
|
+
return rows;
|
|
638
|
+
const timeoutMs = options.timeoutMs ?? 60_000;
|
|
639
|
+
const controller = new AbortController();
|
|
640
|
+
let timer;
|
|
641
|
+
try {
|
|
642
|
+
// Abort is only a request; a model that ignores it would otherwise hold
|
|
643
|
+
// the save forever, so the race is what bounds the wait.
|
|
644
|
+
const { output, usage } = await Promise.race([
|
|
645
|
+
generateText({
|
|
646
|
+
model: options.model,
|
|
647
|
+
output: Output.object({ schema: SELECT_SCHEMA }),
|
|
648
|
+
system: systemPrompt(limit),
|
|
649
|
+
prompt: buildUserPrompt(rows, publicationDate, limit),
|
|
650
|
+
abortSignal: controller.signal,
|
|
651
|
+
}),
|
|
652
|
+
new Promise((_, reject) => {
|
|
653
|
+
timer = setTimeout(() => {
|
|
654
|
+
controller.abort();
|
|
655
|
+
reject(new Error(`selection timed out after ${timeoutMs}ms`));
|
|
656
|
+
}, timeoutMs);
|
|
657
|
+
}),
|
|
658
|
+
]);
|
|
659
|
+
const usable = (index) => Number.isInteger(index) && index >= 0 && index < rows.length;
|
|
660
|
+
const chosen = new Set();
|
|
661
|
+
for (const index of output.select) {
|
|
662
|
+
if (chosen.size === limit)
|
|
663
|
+
break;
|
|
664
|
+
if (usable(index))
|
|
665
|
+
chosen.add(index);
|
|
666
|
+
}
|
|
667
|
+
// Every candidate is a verified, current action, so an empty section is
|
|
668
|
+
// a malformed answer rather than a judgement that nothing matters.
|
|
669
|
+
if (!chosen.size)
|
|
670
|
+
return fallback(rows, 'no usable index in the selection');
|
|
671
|
+
const duplicates = new Set((output.duplicates ?? []).filter((index) => usable(index) && !chosen.has(index)));
|
|
672
|
+
// The prompt asks for a full section; a short answer is filled by date
|
|
673
|
+
// rather than trusted, but never with a row the model called a repeat.
|
|
674
|
+
let filledCount = 0;
|
|
675
|
+
for (let index = 0; index < rows.length; index++) {
|
|
676
|
+
if (chosen.size === limit)
|
|
677
|
+
break;
|
|
678
|
+
if (chosen.has(index) || duplicates.has(index))
|
|
679
|
+
continue;
|
|
680
|
+
chosen.add(index);
|
|
681
|
+
filledCount++;
|
|
682
|
+
}
|
|
683
|
+
options.onSelected?.({
|
|
684
|
+
candidateCount: rows.length,
|
|
685
|
+
selectedCount: chosen.size,
|
|
686
|
+
filledCount,
|
|
687
|
+
usage,
|
|
688
|
+
});
|
|
689
|
+
return rows.filter((_, index) => chosen.has(index));
|
|
690
|
+
}
|
|
691
|
+
catch (error) {
|
|
692
|
+
return fallback(rows, error instanceof Error ? error.message : String(error));
|
|
693
|
+
}
|
|
694
|
+
finally {
|
|
695
|
+
clearTimeout(timer);
|
|
696
|
+
}
|
|
697
|
+
};
|
|
698
|
+
};
|
|
699
|
+
|
|
304
700
|
/**
|
|
305
701
|
* Reads what data.go.kr said when it refused a request.
|
|
306
702
|
*
|
|
@@ -4679,224 +5075,6 @@ ${poweredByFooterHtml()}
|
|
|
4679
5075
|
</body>
|
|
4680
5076
|
</html>`;
|
|
4681
5077
|
|
|
4682
|
-
/**
|
|
4683
|
-
* Date service implementation
|
|
4684
|
-
* - Provides newsletter publication date strings (ISO and localized display form)
|
|
4685
|
-
* - Always returns Korea Standard Time (KST, Asia/Seoul) regardless of server timezone
|
|
4686
|
-
* - Accepts optional publishDate to override "today" (e.g., generating today's run for tomorrow's publication)
|
|
4687
|
-
*/
|
|
4688
|
-
class DateService {
|
|
4689
|
-
targetDate;
|
|
4690
|
-
/**
|
|
4691
|
-
* @param publishDate - Optional ISO date string (YYYY-MM-DD) representing the newsletter
|
|
4692
|
-
* publication date. If omitted, the current wall-clock time (KST)
|
|
4693
|
-
* is used. Pass tomorrow's date when building the issue the night before.
|
|
4694
|
-
* @throws {Error} If publishDate is not in YYYY-MM-DD format or is not a real calendar date.
|
|
4695
|
-
*/
|
|
4696
|
-
constructor(publishDate) {
|
|
4697
|
-
if (publishDate !== undefined) {
|
|
4698
|
-
if (!/^\d{4}-\d{2}-\d{2}$/.test(publishDate)) {
|
|
4699
|
-
throw new Error(`Invalid publishDate format: "${publishDate}". Expected YYYY-MM-DD (e.g., "2025-02-12").`);
|
|
4700
|
-
}
|
|
4701
|
-
const date = new Date(publishDate + 'T00:00:00+09:00');
|
|
4702
|
-
// Round-trip check: format back to YYYY-MM-DD in KST and compare.
|
|
4703
|
-
// Catches invalid dates like "2025-02-30" that JS silently normalizes to "2025-03-02".
|
|
4704
|
-
const roundTrip = date.toLocaleDateString('en-CA', {
|
|
4705
|
-
timeZone: 'Asia/Seoul',
|
|
4706
|
-
});
|
|
4707
|
-
if (roundTrip !== publishDate) {
|
|
4708
|
-
throw new Error(`Invalid publishDate: "${publishDate}" is not a real calendar date.`);
|
|
4709
|
-
}
|
|
4710
|
-
this.targetDate = date;
|
|
4711
|
-
}
|
|
4712
|
-
else {
|
|
4713
|
-
this.targetDate = new Date();
|
|
4714
|
-
}
|
|
4715
|
-
}
|
|
4716
|
-
/**
|
|
4717
|
-
* Get the newsletter publication date in ISO format (YYYY-MM-DD).
|
|
4718
|
-
* - Always returns date in Korea Standard Time (UTC+9)
|
|
4719
|
-
* @returns ISO date string (e.g., "2024-10-15")
|
|
4720
|
-
*/
|
|
4721
|
-
getPublicationISODateString() {
|
|
4722
|
-
// Use Intl.DateTimeFormat to get date in Korea timezone
|
|
4723
|
-
// 'en-CA' locale returns YYYY-MM-DD format by default
|
|
4724
|
-
const kstDate = this.targetDate.toLocaleDateString('en-CA', {
|
|
4725
|
-
timeZone: 'Asia/Seoul',
|
|
4726
|
-
});
|
|
4727
|
-
return kstDate;
|
|
4728
|
-
}
|
|
4729
|
-
getCurrentISODateString() {
|
|
4730
|
-
return this.getPublicationISODateString();
|
|
4731
|
-
}
|
|
4732
|
-
/**
|
|
4733
|
-
* Get the newsletter publication date as a localized display string.
|
|
4734
|
-
* - Always returns date in Korea Standard Time (UTC+9)
|
|
4735
|
-
* @returns Korean formatted date (e.g., "2024년 10월 15일")
|
|
4736
|
-
*/
|
|
4737
|
-
getPublicationDisplayDateString() {
|
|
4738
|
-
const formatter = new Intl.DateTimeFormat('ko-KR', {
|
|
4739
|
-
timeZone: 'Asia/Seoul',
|
|
4740
|
-
year: 'numeric',
|
|
4741
|
-
month: 'long',
|
|
4742
|
-
day: 'numeric',
|
|
4743
|
-
});
|
|
4744
|
-
return formatter.format(this.targetDate);
|
|
4745
|
-
}
|
|
4746
|
-
getDisplayDateString() {
|
|
4747
|
-
return this.getPublicationDisplayDateString();
|
|
4748
|
-
}
|
|
4749
|
-
}
|
|
4750
|
-
|
|
4751
|
-
function escapeLabel(value) {
|
|
4752
|
-
return value
|
|
4753
|
-
.replace(/\s+/g, ' ')
|
|
4754
|
-
.replace(/&/g, '&')
|
|
4755
|
-
.replace(/</g, '<')
|
|
4756
|
-
.replace(/>/g, '>')
|
|
4757
|
-
.replace(/[\\`*_{}[\]()|!#]/g, '\\$&');
|
|
4758
|
-
}
|
|
4759
|
-
const clockPattern = /^(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d)?$/;
|
|
4760
|
-
const fullClock = (time) => (time.length === 5 ? `${time}:00` : time);
|
|
4761
|
-
function calendarMs(date) {
|
|
4762
|
-
if (!/^\d{4}-\d{2}-\d{2}$/.test(date))
|
|
4763
|
-
return NaN;
|
|
4764
|
-
const ms = Date.parse(`${date}T00:00:00Z`);
|
|
4765
|
-
return Number.isFinite(ms) && new Date(ms).toISOString().slice(0, 10) === date
|
|
4766
|
-
? ms
|
|
4767
|
-
: NaN;
|
|
4768
|
-
}
|
|
4769
|
-
/** Deterministic deadlines/events, no LLM context. Host owns selection and history. */
|
|
4770
|
-
function renderVerifiedDeadlineReminders(reminders, publicationDate, now = new Date()) {
|
|
4771
|
-
const date = new DateService(publicationDate).getPublicationISODateString();
|
|
4772
|
-
const publicationMs = Date.parse(`${date}T00:00:00Z`);
|
|
4773
|
-
const rows = reminders
|
|
4774
|
-
.flatMap((reminder) => {
|
|
4775
|
-
const { deadline } = reminder;
|
|
4776
|
-
if (reminder.verificationStatus !== 'verified' ||
|
|
4777
|
-
deadline.status !== 'active' ||
|
|
4778
|
-
!deadline.date ||
|
|
4779
|
-
!/^\d{4}-\d{2}-\d{2}$/.test(deadline.date))
|
|
4780
|
-
return [];
|
|
4781
|
-
const isEvent = deadline.type === 'event';
|
|
4782
|
-
const ms = calendarMs(deadline.date);
|
|
4783
|
-
const endDate = isEvent
|
|
4784
|
-
? (deadline.endDate ?? deadline.date)
|
|
4785
|
-
: deadline.date;
|
|
4786
|
-
const endMs = calendarMs(endDate);
|
|
4787
|
-
if (!Number.isFinite(ms) || !Number.isFinite(endMs) || endMs < ms)
|
|
4788
|
-
return [];
|
|
4789
|
-
if ((!isEvent && (deadline.endDate || deadline.endTime)) ||
|
|
4790
|
-
(deadline.endTime && !deadline.endDate))
|
|
4791
|
-
return [];
|
|
4792
|
-
if ((deadline.time && !clockPattern.test(deadline.time)) ||
|
|
4793
|
-
(deadline.endTime && !clockPattern.test(deadline.endTime)))
|
|
4794
|
-
return [];
|
|
4795
|
-
if (isEvent &&
|
|
4796
|
-
endDate === deadline.date &&
|
|
4797
|
-
deadline.time &&
|
|
4798
|
-
deadline.endTime &&
|
|
4799
|
-
fullClock(deadline.endTime) < fullClock(deadline.time))
|
|
4800
|
-
return [];
|
|
4801
|
-
const days = (ms - publicationMs) / 86_400_000;
|
|
4802
|
-
// Events remain eligible through a known end date; a start time is never
|
|
4803
|
-
// treated as an application cutoff. Unknown endpoints stay unknown.
|
|
4804
|
-
if (days > 7 || endMs < publicationMs || !deadline.title.trim())
|
|
4805
|
-
return [];
|
|
4806
|
-
let url;
|
|
4807
|
-
try {
|
|
4808
|
-
url = new URL(reminder.url);
|
|
4809
|
-
if (!['http:', 'https:'].includes(url.protocol) ||
|
|
4810
|
-
url.username ||
|
|
4811
|
-
url.password)
|
|
4812
|
-
return [];
|
|
4813
|
-
if (deadline.timeZone)
|
|
4814
|
-
new Intl.DateTimeFormat('en', { timeZone: deadline.timeZone });
|
|
4815
|
-
const closingTime = isEvent ? deadline.endTime : deadline.time;
|
|
4816
|
-
if (closingTime) {
|
|
4817
|
-
const parts = new Intl.DateTimeFormat('en', {
|
|
4818
|
-
timeZone: deadline.timeZone ?? 'Asia/Seoul',
|
|
4819
|
-
year: 'numeric',
|
|
4820
|
-
month: '2-digit',
|
|
4821
|
-
day: '2-digit',
|
|
4822
|
-
hour: '2-digit',
|
|
4823
|
-
minute: '2-digit',
|
|
4824
|
-
second: '2-digit',
|
|
4825
|
-
hourCycle: 'h23',
|
|
4826
|
-
}).formatToParts(now);
|
|
4827
|
-
const values = Object.fromEntries(parts.map(({ type, value }) => [type, value]));
|
|
4828
|
-
const localNow = `${values.year}-${values.month}-${values.day} ${values.hour}:${values.minute}:${values.second}`;
|
|
4829
|
-
const closes = `${endDate} ${fullClock(closingTime)}`;
|
|
4830
|
-
if (closes <= localNow)
|
|
4831
|
-
return [];
|
|
4832
|
-
}
|
|
4833
|
-
}
|
|
4834
|
-
catch {
|
|
4835
|
-
return [];
|
|
4836
|
-
}
|
|
4837
|
-
return [
|
|
4838
|
-
{
|
|
4839
|
-
reminder,
|
|
4840
|
-
days,
|
|
4841
|
-
ms,
|
|
4842
|
-
url: url.href.replace(/[()]/g, (value) => encodeURIComponent(value)),
|
|
4843
|
-
},
|
|
4844
|
-
];
|
|
4845
|
-
})
|
|
4846
|
-
.sort((a, b) =>
|
|
4847
|
-
// The five-row limit must not let older ongoing events displace
|
|
4848
|
-
// today's or upcoming deadlines/events. Ongoing events fill spare rows.
|
|
4849
|
-
Number(a.days < 0) - Number(b.days < 0) ||
|
|
4850
|
-
a.ms - b.ms ||
|
|
4851
|
-
(a.reminder.deadline.time ?? '23:59:59').localeCompare(b.reminder.deadline.time ?? '23:59:59'));
|
|
4852
|
-
const seen = new Set();
|
|
4853
|
-
const lines = [];
|
|
4854
|
-
for (const { reminder, days, url } of rows) {
|
|
4855
|
-
const d = reminder.deadline;
|
|
4856
|
-
const key = JSON.stringify([
|
|
4857
|
-
url,
|
|
4858
|
-
d.type ?? 'deadline',
|
|
4859
|
-
d.title,
|
|
4860
|
-
d.kind,
|
|
4861
|
-
d.date,
|
|
4862
|
-
d.time,
|
|
4863
|
-
d.endDate ?? null,
|
|
4864
|
-
d.endTime ?? null,
|
|
4865
|
-
]);
|
|
4866
|
-
if (seen.has(key))
|
|
4867
|
-
continue;
|
|
4868
|
-
seen.add(key);
|
|
4869
|
-
const isEvent = d.type === 'event';
|
|
4870
|
-
const time = d.time ? ` ${d.time}` : '';
|
|
4871
|
-
const end = isEvent && d.endDate
|
|
4872
|
-
? d.endDate !== d.date
|
|
4873
|
-
? ` ~ ${d.endDate}${d.endTime ? ` ${d.endTime}` : ''}`
|
|
4874
|
-
: d.endTime
|
|
4875
|
-
? ` ~ ${d.endTime}`
|
|
4876
|
-
: ''
|
|
4877
|
-
: '';
|
|
4878
|
-
const zone = (d.time || (isEvent && d.endTime)) && d.timeZone
|
|
4879
|
-
? ` (${escapeLabel(d.timeZone)})`
|
|
4880
|
-
: '';
|
|
4881
|
-
const timing = days > 0
|
|
4882
|
-
? `D-${days}`
|
|
4883
|
-
: days < 0
|
|
4884
|
-
? '진행 중'
|
|
4885
|
-
: isEvent
|
|
4886
|
-
? /공개/.test(d.kind)
|
|
4887
|
-
? '오늘 공개'
|
|
4888
|
-
: '오늘 개최'
|
|
4889
|
-
: '오늘 마감';
|
|
4890
|
-
const label = d.title.includes(d.kind) ? d.title : `${d.title} · ${d.kind}`;
|
|
4891
|
-
lines.push(`| [${escapeLabel(label)}](${url}) | **${d.date}${time}${end}${zone} · ${timing}** |`);
|
|
4892
|
-
if (lines.length === 5)
|
|
4893
|
-
break;
|
|
4894
|
-
}
|
|
4895
|
-
return lines.length
|
|
4896
|
-
? `## ⏰ 다가오는 일정·마감\n\n| 안내 | 일정 |\n| --- | --- |\n${lines.join('\n')}`
|
|
4897
|
-
: '';
|
|
4898
|
-
}
|
|
4899
|
-
|
|
4900
5078
|
function canonicalSourceUrl(value) {
|
|
4901
5079
|
try {
|
|
4902
5080
|
const url = new URL(value);
|
|
@@ -5007,6 +5185,7 @@ class ContentGenerateProvider {
|
|
|
5007
5185
|
articleRepository;
|
|
5008
5186
|
newsletterRepository;
|
|
5009
5187
|
templateOptions;
|
|
5188
|
+
selectDeadlineReminders;
|
|
5010
5189
|
_issueOrder = null;
|
|
5011
5190
|
deadlineRemindersMarkdown;
|
|
5012
5191
|
model;
|
|
@@ -5015,10 +5194,13 @@ class ContentGenerateProvider {
|
|
|
5015
5194
|
htmlTemplate;
|
|
5016
5195
|
/** Newsletter brand name (defaults to config, can be overridden via constructor) */
|
|
5017
5196
|
newsletterBrandName;
|
|
5018
|
-
constructor(model, articleRepository, newsletterRepository, templateOptions, brandName
|
|
5197
|
+
constructor(model, articleRepository, newsletterRepository, templateOptions, brandName,
|
|
5198
|
+
/** Chooses displayed reminders; omitted, the first rows by date display. */
|
|
5199
|
+
selectDeadlineReminders) {
|
|
5019
5200
|
this.articleRepository = articleRepository;
|
|
5020
5201
|
this.newsletterRepository = newsletterRepository;
|
|
5021
5202
|
this.templateOptions = templateOptions;
|
|
5203
|
+
this.selectDeadlineReminders = selectDeadlineReminders;
|
|
5022
5204
|
this.model = model;
|
|
5023
5205
|
this.deadlineRemindersMarkdown =
|
|
5024
5206
|
templateOptions?.deadlineRemindersMarkdown?.trim() ?? '';
|
|
@@ -5086,9 +5268,9 @@ class ContentGenerateProvider {
|
|
|
5086
5268
|
throw new Error('Generated body contains the sharing link before the closing block');
|
|
5087
5269
|
const reminders = collectNewsletterDeadlines(newsletter.content, usedArticles, this.templateOptions?.verifiedDeadlineReminders ?? []);
|
|
5088
5270
|
const markdown = this.templateOptions?.verifiedDeadlineReminders !== undefined
|
|
5089
|
-
?
|
|
5271
|
+
? await this.renderDeadlineReminders(reminders, newsletter.date)
|
|
5090
5272
|
: this.deadlineRemindersMarkdown ||
|
|
5091
|
-
|
|
5273
|
+
(await this.renderDeadlineReminders(reminders, newsletter.date));
|
|
5092
5274
|
const share = this.templateOptions?.shareNoticeMarkdown ??
|
|
5093
5275
|
`이 소식이 도움이 되셨다면 동료 연구자에게도 소개해주시면 좋겠습니다. [${escapeLabel(this.newsletterBrandName)} 구독하기](${this.subscribePageUrl})`;
|
|
5094
5276
|
// Render only the closing block with the original stylesheet. Keep core's
|
|
@@ -5113,6 +5295,12 @@ class ContentGenerateProvider {
|
|
|
5113
5295
|
},
|
|
5114
5296
|
});
|
|
5115
5297
|
}
|
|
5298
|
+
async renderDeadlineReminders(reminders, publicationDate) {
|
|
5299
|
+
if (!this.selectDeadlineReminders)
|
|
5300
|
+
return renderVerifiedDeadlineReminders(reminders, publicationDate);
|
|
5301
|
+
const rows = eligibleDeadlineReminders(reminders, publicationDate);
|
|
5302
|
+
return formatDeadlineReminders(await this.selectDeadlineReminders(rows, publicationDate));
|
|
5303
|
+
}
|
|
5116
5304
|
}
|
|
5117
5305
|
|
|
5118
5306
|
/**
|
|
@@ -5599,7 +5787,24 @@ function createNewsletterGenerator(dependencies) {
|
|
|
5599
5787
|
: dependencies.contentGeneration
|
|
5600
5788
|
? createContentGenerationModel(dependencies.contentGeneration)
|
|
5601
5789
|
: resolveModel('generateNewsletter');
|
|
5602
|
-
const contentGenerateProvider = new ContentGenerateProvider(contentModel, dependencies.articleRepository, dependencies.newsletterRepository, templateOptions, resolvedBrandName
|
|
5790
|
+
const contentGenerateProvider = new ContentGenerateProvider(contentModel, dependencies.articleRepository, dependencies.newsletterRepository, templateOptions, resolvedBrandName,
|
|
5791
|
+
// Reminder selection judges relevance the way importance scoring does, so
|
|
5792
|
+
// it reuses that model rather than adding another configuration knob.
|
|
5793
|
+
createDeadlineReminderSelector({
|
|
5794
|
+
model: resolveModel('determineImportance'),
|
|
5795
|
+
onFallback: (reason, candidateCount) => {
|
|
5796
|
+
dependencies.logger?.info({
|
|
5797
|
+
event: 'newsletter.deadlines.selection.fallback',
|
|
5798
|
+
data: { reason, candidateCount },
|
|
5799
|
+
});
|
|
5800
|
+
},
|
|
5801
|
+
onSelected: (data) => {
|
|
5802
|
+
dependencies.logger?.info({
|
|
5803
|
+
event: 'newsletter.deadlines.selection',
|
|
5804
|
+
data,
|
|
5805
|
+
});
|
|
5806
|
+
},
|
|
5807
|
+
}));
|
|
5603
5808
|
return new GenerateNewsletter({
|
|
5604
5809
|
contentOptions: resolvedContentOptions,
|
|
5605
5810
|
promptProvider: dependencies.promptProvider ?? researchRadarPromptProvider,
|
|
@@ -6124,5 +6329,5 @@ async function refreshResearchRadarDeadlines(config) {
|
|
|
6124
6329
|
}
|
|
6125
6330
|
}
|
|
6126
6331
|
|
|
6127
|
-
export { AnalysisProvider, ContentGenerateProvider, CrawlingProvider, DateService, TaskService, contentOptions, createCrawlingTargetGroups, extractResearchRadarDeadlines, fetchResearchRadarDeadlineSource, generateNewsletter, generateWelcomeHTML, getSourceList, llmConfig, maximumImportanceScoreByDomain, newsletterConfig, refreshResearchRadarDeadlines, renderVerifiedDeadlineReminders, researchRadarPromptProvider, robotsExemptOrigins };
|
|
6332
|
+
export { AnalysisProvider, ContentGenerateProvider, CrawlingProvider, DEADLINE_REMINDER_LEAD_DAYS, DEADLINE_REMINDER_LIMIT, DateService, TaskService, contentOptions, createCrawlingTargetGroups, createDeadlineReminderSelector, extractResearchRadarDeadlines, fetchResearchRadarDeadlineSource, generateNewsletter, generateWelcomeHTML, getSourceList, llmConfig, maximumImportanceScoreByDomain, newsletterConfig, refreshResearchRadarDeadlines, renderVerifiedDeadlineReminders, researchRadarPromptProvider, robotsExemptOrigins };
|
|
6128
6333
|
//# sourceMappingURL=index.js.map
|
package/dist/index.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":"
|
|
1
|
+
{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
|
package/package.json
CHANGED
|
@@ -2,7 +2,7 @@
|
|
|
2
2
|
"name": "@heripo/research-radar",
|
|
3
3
|
"private": false,
|
|
4
4
|
"type": "module",
|
|
5
|
-
"version": "6.0
|
|
5
|
+
"version": "6.1.0",
|
|
6
6
|
"description": "AI-driven intelligence for Korean cultural heritage. This package serves as both a ready-to-use newsletter service and a practical implementation example for the LLM-Newsletter-Kit.",
|
|
7
7
|
"main": "dist/index.js",
|
|
8
8
|
"types": "dist/index.d.ts",
|
|
@@ -65,7 +65,7 @@
|
|
|
65
65
|
},
|
|
66
66
|
"devDependencies": {
|
|
67
67
|
"@eslint/js": "^10.0.1",
|
|
68
|
-
"@llm-newsletter-kit/core": "^3.1.
|
|
68
|
+
"@llm-newsletter-kit/core": "^3.1.3",
|
|
69
69
|
"@trivago/prettier-plugin-sort-imports": "^6.0.2",
|
|
70
70
|
"@types/express": "^5.0.6",
|
|
71
71
|
"@types/jsdom": "^30.0.0",
|
|
@@ -110,7 +110,7 @@
|
|
|
110
110
|
"example"
|
|
111
111
|
],
|
|
112
112
|
"engines": {
|
|
113
|
-
"node": "^24.
|
|
113
|
+
"node": "^24.22.1 || >=26.12.1"
|
|
114
114
|
},
|
|
115
115
|
"publishConfig": {
|
|
116
116
|
"access": "public"
|
|
@@ -120,7 +120,7 @@
|
|
|
120
120
|
"fsevents@2.3.3": true
|
|
121
121
|
},
|
|
122
122
|
"overrides": {
|
|
123
|
-
"body-parser": "^2.
|
|
123
|
+
"body-parser": "^2.4.0",
|
|
124
124
|
"postcss": "^8.5.23"
|
|
125
125
|
}
|
|
126
126
|
}
|