@nocville/npc 0.0.0-stage → 0.2.0

package/dist/cjs/npcs/cursor/setup.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CURSOR_HOOK_EVENTS = void 0;
+exports.cursorSettingsPath = cursorSettingsPath;
+exports.installCursorHooksInto = installCursorHooksInto;
+exports.buildCursorHookCommand = buildCursorHookCommand;
+exports.setupCursorHooks = setupCursorHooks;
+exports.uninstallCursorHooks = uninstallCursorHooks;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const user_config_js_1 = require("../../core/user-config.js");
+const hook_settings_js_1 = require("../agent-common/hook-settings.js");
+const shim_js_1 = require("../agent-common/shim.js");
+const runtime_js_1 = require("../agent-common/runtime.js");
+const defaults_js_1 = require("./defaults.js");
+/** Telemetry hooks only; model output and prompt text never enter Nocville. */
+exports.CURSOR_HOOK_EVENTS = [
+    'sessionStart',
+    'sessionEnd',
+    'beforeSubmitPrompt',
+    'postToolUse',
+    'postToolUseFailure',
+    'afterFileEdit',
+    'stop',
+    'subagentStop',
+    'preCompact',
+];
+function cursorSettingsPath() {
+    return (0, node_path_1.join)((0, defaults_js_1.cursorHome)(), 'hooks.json');
+}
+/** Install the nocville group into every Cursor event. Mutates `file`. */
+function installCursorHooksInto(file, command, opts = {}) {
+    const migrated = (0, hook_settings_js_1.removeHookGroups)(file);
+    file.version = 1;
+    file.hooks ??= {};
+    for (const event of exports.CURSOR_HOOK_EVENTS) {
+        const existing = Array.isArray(file.hooks[event]) ? file.hooks[event] : [];
+        file.hooks[event] = [
+            ...existing,
+            { command, timeout: opts.timeout ?? defaults_js_1.CURSOR_DEFAULTS.hookTimeoutSeconds },
+        ];
+    }
+    return { migrated, installed: exports.CURSOR_HOOK_EVENTS.length };
+}
+function buildCursorHookCommand(_cliPath) {
+    return (0, hook_settings_js_1.buildShimHookCommand)('cursor');
+}
+function out(opts, msg) {
+    if (!opts.quiet)
+        console.log(msg);
+}
+/** Merge into Cursor settings, preserving user hooks and a one-time backup. */
+function setupCursorHooks(opts = {}) {
+    const settingsPath = opts.settingsPath ?? cursorSettingsPath();
+    const dir = (0, node_path_1.join)(settingsPath, '..');
+    if (!(0, node_fs_1.existsSync)(dir)) {
+        console.error(`${dir} does not exist — is Cursor installed? Skipping Cursor setup.`);
+        return false;
+    }
+    const file = (0, hook_settings_js_1.readJsonFile)(settingsPath);
+    if (file === null ||
+        (file.version !== undefined && file.version !== 1) ||
+        (file.hooks !== undefined &&
+            (!file.hooks || typeof file.hooks !== 'object' || Array.isArray(file.hooks)))) {
+        console.error(`Unsupported or invalid Cursor hook settings in ${settingsPath}; no settings changed.`);
+        return false;
+    }
+    const creds = (0, user_config_js_1.persistCredentials)(opts);
+    const resolved = (0, hook_settings_js_1.resolveCliPath)(opts.cliPath);
+    const cliPath = (0, runtime_js_1.ensureStableCliPath)(resolved);
+    (0, shim_js_1.installHookShim)((0, hook_settings_js_1.stableNodePath)(), cliPath);
+    const { installed } = installCursorHooksInto(file, buildCursorHookCommand(cliPath), {
+        timeout: defaults_js_1.CURSOR_DEFAULTS.hookTimeoutSeconds,
+    });
+    (0, hook_settings_js_1.writeJsonFile)(settingsPath, file);
+    out(opts, `✓ Cursor: installed Nocville hooks for ${installed} events in ${settingsPath}`);
+    out(opts, `  Hook runs: ${process.execPath} ${cliPath}`);
+    out(opts, `  API: ${creds.apiUrl ?? 'https://nocville.com'}  key: ${(0, user_config_js_1.maskKey)(creds.apiKey)}`);
+    if (!creds.apiKey) {
+        out(opts, '  ⚠ No API key saved yet — run: nocville-npc init --api-key=<your team key>');
+    }
+    return true;
+}
+/** Remove all Nocville hooks from `~/.cursor/hooks.json`. */
+function uninstallCursorHooks(opts = {}) {
+    const settingsPath = opts.settingsPath ?? cursorSettingsPath();
+    const file = (0, hook_settings_js_1.readJsonFile)(settingsPath);
+    if (!file || !(0, node_fs_1.existsSync)(settingsPath)) {
+        out(opts, 'Cursor: no hooks.json — nothing to remove.');
+        return 0;
+    }
+    const removed = (0, hook_settings_js_1.removeHookGroups)(file);
+    if (removed > 0)
+        (0, hook_settings_js_1.writeJsonFile)(settingsPath, file);
+    out(opts, `✓ Cursor: removed ${removed} Nocville hook(s) from ${settingsPath}`);
+    return removed;
+}
+//# sourceMappingURL=setup.js.map

package/dist/cjs/npcs/gemini/defaults.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geminiHome = exports.GEMINI_DEFAULTS = void 0;
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+exports.GEMINI_DEFAULTS = {
+    stateDir: (0, node_path_1.join)((0, node_os_1.tmpdir)(), 'nocville-gemini'),
+    stateFileMaxAge: 24 * 60 * 60 * 1000,
+    heartbeatSeconds: 90,
+    minPushGapMs: 1500,
+    hookTimeoutMs: 5000,
+};
+const geminiHome = () => (0, node_path_1.join)((0, node_os_1.homedir)(), '.gemini');
+exports.geminiHome = geminiHome;
+//# sourceMappingURL=defaults.js.map

package/dist/cjs/npcs/gemini/hook-handler.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GEMINI_HOOK_SPEC = exports.GEMINI_ADAPTER = void 0;
+exports.geminiServiceId = geminiServiceId;
+exports.geminiTransition = geminiTransition;
+exports.handleGeminiHookEvent = handleGeminiHookEvent;
+const activity_js_1 = require("../agent-common/activity.js");
+const hook_runner_js_1 = require("../agent-common/hook-runner.js");
+const session_js_1 = require("../agent-common/session.js");
+const defaults_js_1 = require("./defaults.js");
+exports.GEMINI_ADAPTER = {
+    command: 'gemini',
+    label: 'Gemini',
+    family: 'gemini',
+    stateDir: defaults_js_1.GEMINI_DEFAULTS.stateDir,
+    heartbeatSeconds: defaults_js_1.GEMINI_DEFAULTS.heartbeatSeconds,
+    processNames: ['gemini', 'node'],
+    nodeCommandPattern: /[\/\\](?:@google[\/\\])?gemini(?:-cli[\/\\]|(?:\.[cm]?js)?(?:\s|$))/i,
+};
+function geminiServiceId(sessionId, cwd) {
+    return (0, session_js_1.sanitizeServiceId)(`gemini-${(0, session_js_1.projectNameOf)(cwd)}-${sessionId.slice(0, 8)}`);
+}
+const idle = (activity) => ({
+    state: 'IDLE',
+    activity,
+    status: 'healthy',
+    mood: 'idle',
+});
+const working = (activity, warning = false) => ({
+    state: 'WORKING',
+    activity,
+    status: warning ? 'warning' : 'healthy',
+    mood: warning ? 'concerned' : 'happy',
+});
+/** Only phase and tool metadata are used; prompts/responses/transcripts are never read. */
+function geminiTransition(event, prev) {
+    const cwd = typeof event.cwd === 'string' ? event.cwd : prev?.projectDir;
+    switch ((0, hook_runner_js_1.hookEventName)(event)) {
+        case 'SessionStart':
+            return idle('Ready for a task');
+        case 'BeforeAgent':
+            return working(activity_js_1.THINKING);
+        case 'BeforeTool':
+            return working((0, activity_js_1.describeToolUse)(event.tool_name, event.tool_input, cwd));
+        case 'AfterTool': {
+            const response = event['tool_response'];
+            if (response && typeof response === 'object' && 'error' in response && response.error)
+                return working((0, activity_js_1.failureText)(event.tool_name), true);
+            return { ...working(), quiet: prev?.state === 'WORKING' };
+        }
+        case 'Notification':
+            if (event['notification_type'] === 'ToolPermission')
+                return {
+                    state: 'WAITING',
+                    status: 'warning',
+                    mood: 'concerned',
+                    activity: 'Needs your approval',
+                };
+            break;
+        case 'AfterAgent':
+            return idle('Done — waiting for next task');
+        case 'PreCompress':
+            return working('Compacting context');
+        case 'SessionEnd':
+            return {
+                state: 'IDLE',
+                activity: 'Session ended',
+                status: 'unknown',
+                mood: 'idle',
+                offline: true,
+            };
+    }
+    return {
+        state: prev?.state ?? 'IDLE',
+        status: prev?.status ?? 'healthy',
+        mood: prev?.mood ?? 'idle',
+        quiet: true,
+    };
+}
+exports.GEMINI_HOOK_SPEC = {
+    adapter: exports.GEMINI_ADAPTER,
+    serviceIdFor: geminiServiceId,
+    transition: geminiTransition,
+    stdoutOnSuccess: '{}',
+    statsEvents: ['AfterAgent'],
+};
+async function handleGeminiHookEvent(config, rawInput, opts = {}) {
+    await (0, hook_runner_js_1.runAgentHook)(exports.GEMINI_HOOK_SPEC, config, rawInput ?? (0, hook_runner_js_1.readStdin)(), {
+        minPushGapMs: defaults_js_1.GEMINI_DEFAULTS.minPushGapMs,
+        ...opts,
+    });
+}
+//# sourceMappingURL=hook-handler.js.map

package/dist/cjs/npcs/gemini/index.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GEMINI_HOOK_EVENTS = exports.installGeminiHooksInto = exports.uninstallGeminiHooks = exports.setupGeminiHooks = exports.handleGeminiHookEvent = exports.geminiServiceId = exports.geminiTransition = exports.GEMINI_ADAPTER = exports.GEMINI_DEFAULTS = void 0;
+exports.handleGeminiCommand = handleGeminiCommand;
+const config_js_1 = require("../../core/config.js");
+const hook_runner_js_1 = require("../agent-common/hook-runner.js");
+const watchdog_js_1 = require("../agent-common/watchdog.js");
+const session_js_1 = require("../agent-common/session.js");
+const defaults_js_1 = require("./defaults.js");
+const hook_handler_js_1 = require("./hook-handler.js");
+const setup_js_1 = require("./setup.js");
+var defaults_js_2 = require("./defaults.js");
+Object.defineProperty(exports, "GEMINI_DEFAULTS", { enumerable: true, get: function () { return defaults_js_2.GEMINI_DEFAULTS; } });
+var hook_handler_js_2 = require("./hook-handler.js");
+Object.defineProperty(exports, "GEMINI_ADAPTER", { enumerable: true, get: function () { return hook_handler_js_2.GEMINI_ADAPTER; } });
+Object.defineProperty(exports, "geminiTransition", { enumerable: true, get: function () { return hook_handler_js_2.geminiTransition; } });
+Object.defineProperty(exports, "geminiServiceId", { enumerable: true, get: function () { return hook_handler_js_2.geminiServiceId; } });
+Object.defineProperty(exports, "handleGeminiHookEvent", { enumerable: true, get: function () { return hook_handler_js_2.handleGeminiHookEvent; } });
+var setup_js_2 = require("./setup.js");
+Object.defineProperty(exports, "setupGeminiHooks", { enumerable: true, get: function () { return setup_js_2.setupGeminiHooks; } });
+Object.defineProperty(exports, "uninstallGeminiHooks", { enumerable: true, get: function () { return setup_js_2.uninstallGeminiHooks; } });
+Object.defineProperty(exports, "installGeminiHooksInto", { enumerable: true, get: function () { return setup_js_2.installGeminiHooksInto; } });
+Object.defineProperty(exports, "GEMINI_HOOK_EVENTS", { enumerable: true, get: function () { return setup_js_2.GEMINI_HOOK_EVENTS; } });
+/**
+ * gemini subcommands: setup | uninstall | hook | flush | watchdog | cleanup.
+ * `hook` always emits {}; detached helpers stay silent.
+ */
+async function handleGeminiCommand(opts) {
+    const { subcommand, config, flags } = opts;
+    switch (subcommand) {
+        case 'setup': {
+            if (flags['uninstall']) {
+                (0, setup_js_1.uninstallGeminiHooks)();
+                break;
+            }
+            const ok = (0, setup_js_1.setupGeminiHooks)({
+                apiUrl: (0, config_js_1.stringFlag)(flags, 'api-url') ?? process.env['NOCVILLE_API_URL'],
+                apiKey: (0, config_js_1.stringFlag)(flags, 'api-key') ?? process.env['NOCVILLE_API_KEY'],
+                map: (0, config_js_1.stringFlag)(flags, 'map'),
+                cliPath: process.argv[1],
+            });
+            if (!ok)
+                process.exitCode = 1;
+            break;
+        }
+        case 'uninstall':
+            (0, setup_js_1.uninstallGeminiHooks)();
+            break;
+        case 'hook':
+            await (0, hook_handler_js_1.handleGeminiHookEvent)(config, (0, hook_runner_js_1.readStdin)(), { mode: 'detach' });
+            break;
+        case 'watchdog':
+            await (0, watchdog_js_1.runWatchdog)(hook_handler_js_1.GEMINI_ADAPTER, config, opts.args?.[0]);
+            break;
+        case 'flush':
+            await (0, hook_runner_js_1.runFlushCommand)(hook_handler_js_1.GEMINI_ADAPTER, config, opts.args?.[0], (0, config_js_1.numberFlag)(flags, 'delay'), flags['stats'] === true);
+            break;
+        case 'cleanup': {
+            const removed = await (0, session_js_1.cleanupSessionStates)(defaults_js_1.GEMINI_DEFAULTS.stateDir, defaults_js_1.GEMINI_DEFAULTS.stateFileMaxAge);
+            console.log(`Cleanup complete: ${removed} stale file(s) removed`);
+            break;
+        }
+        default:
+            console.error(`Unknown gemini subcommand: ${subcommand}`);
+            console.error('Available subcommands: setup, uninstall, hook, cleanup');
+            process.exitCode = 1;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/cjs/npcs/gemini/setup.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GEMINI_HOOK_EVENTS = void 0;
+exports.geminiSettingsPath = geminiSettingsPath;
+exports.installGeminiHooksInto = installGeminiHooksInto;
+exports.buildGeminiHookCommand = buildGeminiHookCommand;
+exports.setupGeminiHooks = setupGeminiHooks;
+exports.uninstallGeminiHooks = uninstallGeminiHooks;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const user_config_js_1 = require("../../core/user-config.js");
+const hook_settings_js_1 = require("../agent-common/hook-settings.js");
+const shim_js_1 = require("../agent-common/shim.js");
+const runtime_js_1 = require("../agent-common/runtime.js");
+const defaults_js_1 = require("./defaults.js");
+/** Telemetry hooks only; model output and prompt text never enter Nocville. */
+exports.GEMINI_HOOK_EVENTS = [
+    'SessionStart',
+    'SessionEnd',
+    'BeforeAgent',
+    'BeforeTool',
+    'AfterTool',
+    'Notification',
+    'AfterAgent',
+    'PreCompress',
+];
+function geminiSettingsPath() {
+    return (0, node_path_1.join)((0, defaults_js_1.geminiHome)(), 'settings.json');
+}
+/** Install the nocville group into every Gemini event. Mutates `file`. */
+function installGeminiHooksInto(file, command, opts = {}) {
+    const result = (0, hook_settings_js_1.installHookGroups)(file, command, exports.GEMINI_HOOK_EVENTS, {
+        perEvent: Object.fromEntries(exports.GEMINI_HOOK_EVENTS.map((event) => [
+            event,
+            {
+                name: 'nocville',
+                timeout: opts.timeout ?? defaults_js_1.GEMINI_DEFAULTS.hookTimeoutMs,
+            },
+        ])),
+    });
+    // Omit the optional matcher so lifecycle sources/reasons are all observed too.
+    for (const event of exports.GEMINI_HOOK_EVENTS) {
+        const group = file.hooks[event].at(-1);
+        delete group.matcher;
+    }
+    return result;
+}
+function buildGeminiHookCommand(_cliPath) {
+    return (0, hook_settings_js_1.buildShimHookCommand)('gemini');
+}
+function out(opts, msg) {
+    if (!opts.quiet)
+        console.log(msg);
+}
+/** Merge into Gemini settings, preserving user hooks and a one-time backup. */
+function setupGeminiHooks(opts = {}) {
+    const settingsPath = opts.settingsPath ?? geminiSettingsPath();
+    const dir = (0, node_path_1.join)(settingsPath, '..');
+    if (!(0, node_fs_1.existsSync)(dir)) {
+        console.error(`${dir} does not exist — is Gemini installed? Skipping Gemini setup.`);
+        return false;
+    }
+    const file = (0, hook_settings_js_1.readJsonFile)(settingsPath);
+    if (file === null) {
+        console.error(`Could not parse ${settingsPath}; fix it (or move it aside) and re-run setup.`);
+        return false;
+    }
+    const creds = (0, user_config_js_1.persistCredentials)(opts);
+    const resolved = (0, hook_settings_js_1.resolveCliPath)(opts.cliPath);
+    const cliPath = (0, runtime_js_1.ensureStableCliPath)(resolved);
+    (0, shim_js_1.installHookShim)((0, hook_settings_js_1.stableNodePath)(), cliPath);
+    const { installed } = installGeminiHooksInto(file, buildGeminiHookCommand(cliPath), {
+        timeout: defaults_js_1.GEMINI_DEFAULTS.hookTimeoutMs,
+    });
+    (0, hook_settings_js_1.writeJsonFile)(settingsPath, file);
+    out(opts, `✓ Gemini: installed Nocville hooks for ${installed} events in ${settingsPath}`);
+    out(opts, `  Hook runs: ${process.execPath} ${cliPath}`);
+    out(opts, `  API: ${creds.apiUrl ?? 'https://nocville.com'}  key: ${(0, user_config_js_1.maskKey)(creds.apiKey)}`);
+    if (!creds.apiKey) {
+        out(opts, '  ⚠ No API key saved yet — run: nocville-npc init --api-key=<your team key>');
+    }
+    return true;
+}
+/** Remove all Nocville hooks from `~/.gemini/settings.json`. */
+function uninstallGeminiHooks(opts = {}) {
+    const settingsPath = opts.settingsPath ?? geminiSettingsPath();
+    const file = (0, hook_settings_js_1.readJsonFile)(settingsPath);
+    if (!file || !(0, node_fs_1.existsSync)(settingsPath)) {
+        out(opts, 'Gemini: no settings.json — nothing to remove.');
+        return 0;
+    }
+    const removed = (0, hook_settings_js_1.removeHookGroups)(file);
+    if (removed > 0)
+        (0, hook_settings_js_1.writeJsonFile)(settingsPath, file);
+    out(opts, `✓ Gemini: removed ${removed} Nocville hook(s) from ${settingsPath}`);
+    return removed;
+}
+//# sourceMappingURL=setup.js.map

package/dist/cjs/npcs/github-watcher/defaults.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULTS = void 0;
+exports.DEFAULTS = {
+    pollInterval: 60000, // 60s
+    fetchTimeoutMs: 5000,
+    perPage: 10,
+    /** Polls to keep the 'new-commit' sub-status active after a fresh commit. */
+    newCommitPolls: 2,
+};
+//# sourceMappingURL=defaults.js.map

package/dist/cjs/npcs/github-watcher/format.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relativeTime = relativeTime;
+/** Short relative-time string like "3m ago", "2h ago", "1d ago". */
+function relativeTime(iso, now = Date.now()) {
+    const t = Date.parse(iso);
+    if (!Number.isFinite(t))
+        return 'unknown';
+    const secs = Math.max(0, Math.round((now - t) / 1000));
+    if (secs < 60)
+        return `${secs}s ago`;
+    const mins = Math.round(secs / 60);
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hrs = Math.round(mins / 60);
+    if (hrs < 24)
+        return `${hrs}h ago`;
+    const days = Math.round(hrs / 24);
+    return `${days}d ago`;
+}
+//# sourceMappingURL=format.js.map

package/dist/cjs/npcs/github-watcher/github-api.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchDefaultBranch = fetchDefaultBranch;
+exports.fetchCommits = fetchCommits;
+exports.commitsWithin = commitsWithin;
+exports.newCommitsSince = newCommitsSince;
+function toNum(v) {
+    if (v === null)
+        return null;
+    const n = Number(v);
+    return Number.isNaN(n) ? null : n;
+}
+function ghHeaders(opts) {
+    const headers = {
+        Accept: 'application/vnd.github+json',
+        'User-Agent': 'nocville-npc',
+        'X-GitHub-Api-Version': '2022-11-28',
+    };
+    if (opts.token)
+        headers['Authorization'] = `Bearer ${opts.token}`;
+    return headers;
+}
+/** Look up a repo's default branch (one call at startup). Null on failure. */
+async function fetchDefaultBranch(repo, opts = {}) {
+    const doFetch = opts.fetchFn ?? globalThis.fetch;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? 5000);
+    try {
+        const res = await doFetch(`https://api.github.com/repos/${repo}`, {
+            headers: ghHeaders(opts),
+            signal: controller.signal,
+        });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        return body.default_branch ?? null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Fetch recent commits from the GitHub REST API using conditional requests.
+ * Passing the previous ETag yields a 304 (which does not count against the
+ * unauthenticated 60/hour limit) when nothing has changed. Never throws —
+ * network errors surface as `status: 0`.
+ */
+async function fetchCommits(repo, opts = {}) {
+    const perPage = opts.perPage ?? 10;
+    const doFetch = opts.fetchFn ?? globalThis.fetch;
+    let url = `https://api.github.com/repos/${repo}/commits?per_page=${perPage}`;
+    if (opts.branch)
+        url += `&sha=${encodeURIComponent(opts.branch)}`;
+    const headers = ghHeaders(opts);
+    if (opts.etag)
+        headers['If-None-Match'] = opts.etag;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? 5000);
+    try {
+        const res = await doFetch(url, { headers, signal: controller.signal });
+        const rateRemaining = toNum(res.headers.get('x-ratelimit-remaining'));
+        const etag = res.headers.get('etag');
+        if (res.status === 304) {
+            return {
+                notModified: true,
+                commits: [],
+                etag: opts.etag ?? null,
+                rateRemaining,
+                status: 304,
+            };
+        }
+        if (!res.ok) {
+            await res.text().catch(() => undefined);
+            return { notModified: false, commits: [], etag, rateRemaining, status: res.status };
+        }
+        const body = (await res.json());
+        const commits = body.map((c) => parseCommit(c));
+        return { notModified: false, commits, etag, rateRemaining, status: res.status };
+    }
+    catch {
+        return { notModified: false, commits: [], etag: null, rateRemaining: null, status: 0 };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function parseCommit(c) {
+    const commit = c['commit'] ?? {};
+    const commitAuthor = commit['author'] ?? {};
+    const ghAuthor = c['author'] ?? {};
+    const message = String(commit['message'] ?? '').split('\n')[0] ?? '';
+    return {
+        sha: String(c['sha'] ?? ''),
+        author: String(commitAuthor['name'] ?? ghAuthor['login'] ?? 'unknown'),
+        message,
+        date: String(commitAuthor['date'] ?? ''),
+    };
+}
+/** Count how many commits landed within the last `hours`. */
+function commitsWithin(commits, hours, now = Date.now()) {
+    const cutoff = now - hours * 3600_000;
+    return commits.filter((c) => {
+        const t = Date.parse(c.date);
+        return Number.isFinite(t) && t >= cutoff;
+    }).length;
+}
+/**
+ * Return the commits newer than `lastSeenSha`, newest-first. When the sha isn't
+ * present in the window (more than a page of new commits, or rewritten history)
+ * every fetched commit is treated as new. An undefined sha means "not seeded
+ * yet" — returns empty so the caller can seed without a spurious announcement.
+ */
+function newCommitsSince(commits, lastSeenSha) {
+    if (!lastSeenSha)
+        return [];
+    const idx = commits.findIndex((c) => c.sha === lastSeenSha);
+    if (idx === 0)
+        return []; // newest is already seen
+    if (idx === -1)
+        return commits; // fell out of the window — treat all as new
+    return commits.slice(0, idx);
+}
+//# sourceMappingURL=github-api.js.map