co-maintainer 0.4.3 → 0.4.5

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "co-maintainer",
-    "version": "0.4.3",
+    "version": "0.4.5",
     "description": "Analyzes a GitHub repository and writes repository-specific contribution guidance.",
     "license": "MIT",
     "repository": {

package/dist/src/cli/commands/serve.js

@@ -6,6 +6,7 @@ import { recoverOrphans, startWorkerLoop, stopWorkerLoop, } from "../../services
 import { registerSetupJobHandler } from "../../services/setup.js";
 import { registerReviewJobHandler } from "../../services/review.js";
 import { recoverReplyRequests, registerReplyJobHandler, } from "../../services/replies.js";
+import { startRemakeScheduler, stopRemakeScheduler, } from "../../services/remake_cron.js";
 import { registerRemoteReviewHandler } from "../../services/remote_review.js";
 import { startRemoteWatchdog } from "../../remote/server/sessions.js";
 import { passwordProblem } from "../../util/password.js";
@@ -164,6 +165,7 @@ export async function runServe(args) {
         console.log(`[serve] requeued ${recoveredReplies} unfinished conversation repl${recoveredReplies === 1 ? "y" : "ies"}`);
     }
     startWorkerLoop();
+    startRemakeScheduler();
     if (auth.github)
         console.log(`[serve] GitHub sign-in enabled for ${githubOAuth.allowedUser}`);
     const inject500 = args.includes("--inject-500") || getEnv("CM_INJECT_500") === "1";
@@ -188,6 +190,7 @@ export async function runServe(args) {
             return;
         shuttingDown = true;
         console.log(`[serve] received ${signal}, stopping new requests and closing app.db`);
+        stopRemakeScheduler();
         await stopWorkerLoop();
         await server.shutdown();
         await closeAppDb();

package/dist/src/config.d.ts

@@ -17,6 +17,8 @@ export type RepoConfig = {
     includePullRequestChanges?: boolean;
     includeCommitHistory?: boolean;
     includeHowRepoWorks?: boolean;
+    /** Five field cron in UTC, checked by `serve` to queue a remake. */
+    remakeCron?: string;
 };
 export type UserConfig = {
     auth?: "gh" | "pat";

package/dist/src/server/api/repos.js

@@ -2,6 +2,7 @@ import { errorResponse } from "../errors.js";
 import { findInstallationForRepo } from "../../github/app.js";
 import { activateRepo, deactivateRepo, listActiveRepos, updateRepoSettings, } from "../../store/repos.js";
 import { writeRepoConfig } from "../../config.js";
+import { parseRemakeCron } from "../../services/remake_cron.js";
 import { enqueueSetup } from "../../services/setup.js";
 import { enqueueManualReview } from "../../services/review.js";
 import { prDetail, repoKnowledge, RepoNotFound, repoOverview, repoPulls, requireActiveRepo, } from "../../services/dashboard.js";
@@ -64,6 +65,25 @@ export async function handleReposRoute(request, url, githubApp) {
             catch {
                 return errorResponse(400, "bad_request", "expected a JSON body");
             }
+            const cronPatch = {};
+            if ("remakeCron" in body) {
+                const raw = body.remakeCron;
+                if (raw === null || raw === "") {
+                    cronPatch.remakeCron = undefined;
+                }
+                else if (typeof raw === "string") {
+                    try {
+                        parseRemakeCron(raw);
+                    }
+                    catch (error) {
+                        return errorResponse(422, "invalid_cron", error instanceof Error ? error.message : String(error));
+                    }
+                    cronPatch.remakeCron = raw.trim();
+                }
+                else {
+                    return errorResponse(422, "invalid_cron", "remakeCron must be text or null");
+                }
+            }
             const patch = {};
             if (typeof body.autoReview === "boolean") {
                 patch.auto_review = body.autoReview ? 1 : 0;
@@ -93,8 +113,9 @@ export async function handleReposRoute(request, url, githubApp) {
                     init[key] = body[key];
                 }
             }
-            if (Object.keys(init).length > 0)
-                await writeRepoConfig(fullName, init);
+            if (Object.keys(init).length > 0 || "remakeCron" in cronPatch) {
+                await writeRepoConfig(fullName, { ...init, ...cronPatch });
+            }
             return Response.json({ ok: true });
         }
         if (!sub && request.method === "DELETE") {

package/dist/src/server/pages/repo_settings.js

@@ -1,4 +1,24 @@
 import { html, layout, repoNav, skSlot, text } from "./layout.js";
+import { parseRemakeCron } from "../../services/remake_cron.js";
+import { nextCronRun } from "../../util/cron.js";
+function cronHint(repo, expression) {
+    const notBuilt = repo.knowledge_built_at
+        ? ""
+        : " A schedule only runs after the first setup has finished.";
+    if (!expression) {
+        return `Leave blank to turn it off. For example, 0 3 * * 1 runs every Monday at 03:00.${notBuilt}`;
+    }
+    try {
+        const next = nextCronRun(parseRemakeCron(expression), new Date());
+        if (!next)
+            return `This schedule has no run in the next year.${notBuilt}`;
+        return `Next run ${next.toISOString().slice(0, 16).replace("T", " ")} UTC.${notBuilt}`;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        return `This schedule is ignored, ${reason}.${notBuilt}`;
+    }
+}
 export function renderRepoSettings(username, repo, config) {
     const name = repo.full_name;
     const skip = repo.skip_drafts && repo.skip_bots
@@ -68,6 +88,17 @@ export function renderRepoSettings(username, repo, config) {
       </div>
       <div class="ft"><button class="primary" id="save-init">Save</button></div>
     </div>
+    <div class="card" data-async>
+      ${skSlot()}
+      <div class="hd"><h2>Scheduled remake</h2></div>
+      <div class="bd">
+        <p class="muted" style="margin:0 0 18px">Rebuild the knowledge for this repository on a schedule. Times are UTC and a remake runs at most once an hour.</p>
+        <div class="field wide"><label>Cron schedule</label>
+          <input id="cron" placeholder="0 3 * * 1" value="${text(config.remakeCron ?? "")}">
+          <div class="hint">${text(cronHint(repo, config.remakeCron))}</div></div>
+      </div>
+      <div class="ft"><button class="primary" id="save-cron">Save</button></div>
+    </div>
     <div class="card" data-async>
       ${skSlot()}
       <div class="hd"><h2>Remove</h2></div>
@@ -114,6 +145,9 @@ document.getElementById("save-init").addEventListener("click", function() {
     maxComments: num("comments")
   });
 });
+document.getElementById("save-cron").addEventListener("click", function() {
+  save(this, { remakeCron: document.getElementById("cron").value.trim() });
+});
 document.getElementById("remove").addEventListener("click", function() {
   if (!confirm("Stop reviewing this repository?")) return;
   var btn = this;

package/dist/src/services/remake_cron.d.ts

@@ -0,0 +1,8 @@
+import type { Cron } from "../util/cron.ts";
+/** A remake costs model tokens, so a schedule may fire at most once an hour. */
+export declare function parseRemakeCron(expression: string): Cron;
+/** Each minute is handled once however often the ticker is called. A minute
+ * the process slept through is not made up. */
+export declare function createRemakeCronTicker(): (now: Date) => string[];
+export declare function startRemakeScheduler(intervalMs?: number): void;
+export declare function stopRemakeScheduler(): void;

package/dist/src/services/remake_cron.js

@@ -0,0 +1,63 @@
+import { readConfig } from "../config.js";
+import { getQueuedJobByKey, getRunningJobByKey } from "../store/jobs.js";
+import { listActiveRepos } from "../store/repos.js";
+import { cronMatches, parseCron } from "../util/cron.js";
+import { enqueueSetup } from "./setup.js";
+/** A remake costs model tokens, so a schedule may fire at most once an hour. */
+export function parseRemakeCron(expression) {
+    const cron = parseCron(expression);
+    if (cron.minutes.size !== 1) {
+        throw new Error("the minute field must be a single value, so a remake runs at most once an hour");
+    }
+    return cron;
+}
+/** Each minute is handled once however often the ticker is called. A minute
+ * the process slept through is not made up. */
+export function createRemakeCronTicker() {
+    let lastMinute = -1;
+    return (now) => {
+        const minute = Math.floor(now.getTime() / 60_000);
+        if (minute === lastMinute)
+            return [];
+        lastMinute = minute;
+        const config = readConfig();
+        const queued = [];
+        for (const repo of listActiveRepos()) {
+            const expression = config.repos?.[repo.full_name]?.remakeCron;
+            if (!expression || !repo.knowledge_built_at)
+                continue;
+            let cron;
+            try {
+                cron = parseRemakeCron(expression);
+            }
+            catch {
+                continue;
+            }
+            if (!cronMatches(cron, now))
+                continue;
+            const key = `setup:${repo.full_name}`;
+            if (getQueuedJobByKey(key) || getRunningJobByKey(key))
+                continue;
+            enqueueSetup(repo.full_name, "remake");
+            queued.push(repo.full_name);
+        }
+        return queued;
+    };
+}
+let timer;
+export function startRemakeScheduler(intervalMs = 15_000) {
+    if (timer !== undefined)
+        return;
+    const ticker = createRemakeCronTicker();
+    timer = setInterval(() => {
+        for (const repo of ticker(new Date())) {
+            console.log(`[cron] queued a scheduled remake for ${repo}`);
+        }
+    }, intervalMs);
+}
+export function stopRemakeScheduler() {
+    if (timer === undefined)
+        return;
+    clearInterval(timer);
+    timer = undefined;
+}

package/dist/src/util/cron.d.ts

@@ -0,0 +1,14 @@
+export type Cron = {
+    minutes: Set<number>;
+    hours: Set<number>;
+    daysOfMonth: Set<number>;
+    months: Set<number>;
+    daysOfWeek: Set<number>;
+    anyDayOfMonth: boolean;
+    anyDayOfWeek: boolean;
+};
+export declare function parseCron(expression: string): Cron;
+/** All times are UTC. When both day fields are restricted a date matches if
+ * either one does, as in classic cron. */
+export declare function cronMatches(cron: Cron, date: Date): boolean;
+export declare function nextCronRun(cron: Cron, after: Date): Date | undefined;

package/dist/src/util/cron.js

@@ -0,0 +1,85 @@
+const FIELDS = [
+    { name: "minute", min: 0, max: 59 },
+    { name: "hour", min: 0, max: 23 },
+    { name: "day of month", min: 1, max: 31 },
+    { name: "month", min: 1, max: 12 },
+    { name: "day of week", min: 0, max: 7 },
+];
+function parseNumber(value, name) {
+    if (!/^\d+$/.test(value)) {
+        throw new Error(`${name} has an invalid value "${value}"`);
+    }
+    return Number(value);
+}
+function parseField(text, name, min, max) {
+    const values = new Set();
+    for (const part of text.split(",")) {
+        const [range, stepText, extra] = part.split("/");
+        if (extra !== undefined)
+            throw new Error(`${name} has an invalid step`);
+        const step = stepText === undefined ? 1 : parseNumber(stepText, name);
+        if (step < 1)
+            throw new Error(`${name} step must be at least 1`);
+        let from;
+        let to;
+        if (range === "*") {
+            from = min;
+            to = max;
+        }
+        else if (range.includes("-")) {
+            const [start, end, more] = range.split("-");
+            if (more !== undefined)
+                throw new Error(`${name} has an invalid range`);
+            from = parseNumber(start, name);
+            to = parseNumber(end ?? "", name);
+        }
+        else {
+            from = parseNumber(range, name);
+            to = stepText === undefined ? from : max;
+        }
+        if (from < min || to > max || from > to) {
+            throw new Error(`${name} must be between ${min} and ${max}`);
+        }
+        for (let value = from; value <= to; value += step)
+            values.add(value);
+    }
+    return values;
+}
+export function parseCron(expression) {
+    const fields = expression.trim().split(/\s+/);
+    if (fields.length !== 5) {
+        throw new Error("a cron expression needs 5 fields: minute, hour, day of month, month, day of week");
+    }
+    const [minutes, hours, daysOfMonth, months, daysOfWeek] = FIELDS.map((field, index) => parseField(fields[index], field.name, field.min, field.max));
+    return {
+        minutes,
+        hours,
+        daysOfMonth,
+        months,
+        daysOfWeek: new Set([...daysOfWeek].map((day) => day % 7)),
+        anyDayOfMonth: fields[2].startsWith("*"),
+        anyDayOfWeek: fields[4].startsWith("*"),
+    };
+}
+/** All times are UTC. When both day fields are restricted a date matches if
+ * either one does, as in classic cron. */
+export function cronMatches(cron, date) {
+    if (!cron.minutes.has(date.getUTCMinutes()) ||
+        !cron.hours.has(date.getUTCHours()) ||
+        !cron.months.has(date.getUTCMonth() + 1)) {
+        return false;
+    }
+    const dayOfMonth = cron.daysOfMonth.has(date.getUTCDate());
+    const dayOfWeek = cron.daysOfWeek.has(date.getUTCDay());
+    return cron.anyDayOfMonth || cron.anyDayOfWeek
+        ? dayOfMonth && dayOfWeek
+        : dayOfMonth || dayOfWeek;
+}
+const SEARCH_MINUTES = 366 * 24 * 60;
+export function nextCronRun(cron, after) {
+    let time = Math.floor(after.getTime() / 60_000) * 60_000 + 60_000;
+    for (let step = 0; step < SEARCH_MINUTES; step++, time += 60_000) {
+        if (cronMatches(cron, new Date(time)))
+            return new Date(time);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "co-maintainer",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "Analyzes a GitHub repository and writes repository-specific contribution guidance.",
   "license": "MIT",
   "repository": {