heyio 0.6.0 → 0.9.0

package/dist/store/notifications.js

@@ -0,0 +1,79 @@
+import { getDb } from "./db.js";
+/**
+ * Insert a new background notification. Returns the inserted row including
+ * the autoincrement id and DB-assigned created_at timestamp. source_ref
+ * should be a JSON string or null.
+ */
+export function insertNotification(input) {
+    const db = getDb();
+    const info = db
+        .prepare(`INSERT INTO background_notifications (source_type, source_ref, title, text)
+       VALUES (?, ?, ?, ?)`)
+        .run(input.source_type, input.source_ref, input.title, input.text);
+    return db
+        .prepare("SELECT * FROM background_notifications WHERE id = ?")
+        .get(info.lastInsertRowid);
+}
+/**
+ * List the most recent notifications, newest first. Default limit 50.
+ */
+export function listRecentNotifications(limit = 50) {
+    return getDb()
+        .prepare("SELECT * FROM background_notifications ORDER BY created_at DESC, id DESC LIMIT ?")
+        .all(limit);
+}
+/**
+ * List unread notifications (read_at IS NULL), newest first.
+ */
+export function listUnreadNotifications() {
+    return getDb()
+        .prepare("SELECT * FROM background_notifications WHERE read_at IS NULL ORDER BY created_at DESC, id DESC")
+        .all();
+}
+/**
+ * Count unread notifications. Cheap — uses COUNT(*).
+ */
+export function countUnreadNotifications() {
+    const row = getDb()
+        .prepare("SELECT COUNT(*) AS n FROM background_notifications WHERE read_at IS NULL")
+        .get();
+    return row.n;
+}
+/**
+ * Mark a single notification read. Returns true if the row exists (whether
+ * it was already read or just now marked), false if no such id exists.
+ */
+export function markNotificationRead(id) {
+    const db = getDb();
+    const info = db
+        .prepare("UPDATE background_notifications SET read_at = CURRENT_TIMESTAMP WHERE id = ? AND read_at IS NULL")
+        .run(id);
+    if (info.changes > 0)
+        return true;
+    // Already read — verify the row exists at all
+    const exists = db
+        .prepare("SELECT id FROM background_notifications WHERE id = ?")
+        .get(id);
+    return exists !== undefined;
+}
+/**
+ * Mark every unread notification read. Returns the number of rows affected.
+ */
+export function markAllNotificationsRead() {
+    const info = getDb()
+        .prepare("UPDATE background_notifications SET read_at = CURRENT_TIMESTAMP WHERE read_at IS NULL")
+        .run();
+    return info.changes;
+}
+/**
+ * Delete notifications older than `olderThanDays` days. Returns rows deleted.
+ * Used by a future retention sweep.
+ */
+export function pruneOldNotifications(olderThanDays) {
+    const info = getDb()
+        .prepare(`DELETE FROM background_notifications
+       WHERE created_at < datetime('now', ? || ' days')`)
+        .run(`-${olderThanDays}`);
+    return info.changes;
+}
+//# sourceMappingURL=notifications.js.map

package/dist/store/notifications.test.js

@@ -0,0 +1,197 @@
+/**
+ * Tests for src/store/notifications.ts — SQLite CRUD helpers.
+ *
+ * DB isolation: setDbPathForTests() redirects the SQLite singleton to a
+ * fresh tmp file, ensuring these tests never touch ~/.io/io.db.
+ */
+import { before, after, beforeEach, describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { setDbPathForTests, closeDb, getDb } from "./db.js";
+import { insertNotification, listRecentNotifications, listUnreadNotifications, countUnreadNotifications, markNotificationRead, markAllNotificationsRead, pruneOldNotifications, } from "./notifications.js";
+// ── DB isolation ────────────────────────────────────────────────────────────
+let tmpDir;
+before(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "io-notifs-test-"));
+    setDbPathForTests(join(tmpDir, "io.db"));
+});
+// Wipe all notifications between tests for a clean slate.
+beforeEach(() => {
+    getDb().prepare("DELETE FROM background_notifications").run();
+});
+after(() => {
+    closeDb();
+    rmSync(tmpDir, { recursive: true, force: true });
+});
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function makeNotif(overrides = {}) {
+    return insertNotification({
+        source_type: "io-schedule",
+        source_ref: JSON.stringify({ scheduleId: 1 }),
+        title: "Test Notification",
+        text: "This is the notification body.",
+        ...overrides,
+    });
+}
+// ── insertNotification ───────────────────────────────────────────────────────
+describe("insertNotification", () => {
+    it("returns a row with autoincrement id and created_at timestamp", () => {
+        const row = makeNotif();
+        assert.ok(typeof row.id === "number" && row.id > 0, "id should be a positive integer");
+        assert.ok(row.created_at, "created_at should be set");
+        assert.equal(row.title, "Test Notification");
+        assert.equal(row.text, "This is the notification body.");
+        assert.equal(row.read_at, null);
+    });
+    it("ids are autoincremented across inserts", () => {
+        const a = makeNotif();
+        const b = makeNotif();
+        assert.ok(b.id > a.id, "second id should be greater than first");
+    });
+    it("accepts source_ref: null", () => {
+        const row = makeNotif({ source_ref: null });
+        assert.equal(row.source_ref, null);
+    });
+    it("stores source_type correctly", () => {
+        const row = makeNotif({ source_type: "squad-schedule" });
+        assert.equal(row.source_type, "squad-schedule");
+    });
+});
+// ── listRecentNotifications ──────────────────────────────────────────────────
+describe("listRecentNotifications", () => {
+    it("returns newest first", () => {
+        const a = makeNotif({ title: "First" });
+        const b = makeNotif({ title: "Second" });
+        const c = makeNotif({ title: "Third" });
+        const rows = listRecentNotifications();
+        assert.equal(rows[0].id, c.id, "newest should be first");
+        assert.equal(rows[rows.length - 1].id, a.id, "oldest should be last");
+    });
+    it("default limit is 50", () => {
+        for (let i = 0; i < 55; i++)
+            makeNotif({ title: `N${i}` });
+        const rows = listRecentNotifications();
+        assert.equal(rows.length, 50);
+    });
+    it("explicit limit is honored", () => {
+        for (let i = 0; i < 10; i++)
+            makeNotif({ title: `N${i}` });
+        const rows = listRecentNotifications(3);
+        assert.equal(rows.length, 3);
+    });
+});
+// ── countUnreadNotifications ─────────────────────────────────────────────────
+describe("countUnreadNotifications", () => {
+    it("starts at zero on a clean DB", () => {
+        assert.equal(countUnreadNotifications(), 0);
+    });
+    it("increases on insert", () => {
+        makeNotif();
+        assert.equal(countUnreadNotifications(), 1);
+        makeNotif();
+        assert.equal(countUnreadNotifications(), 2);
+    });
+    it("decreases when a notification is marked read", () => {
+        const a = makeNotif();
+        makeNotif();
+        assert.equal(countUnreadNotifications(), 2);
+        markNotificationRead(a.id);
+        assert.equal(countUnreadNotifications(), 1);
+    });
+});
+// ── markNotificationRead ─────────────────────────────────────────────────────
+describe("markNotificationRead", () => {
+    it("returns false on a non-existent id", () => {
+        assert.equal(markNotificationRead(999999), false);
+    });
+    it("returns true on an existing unread notification", () => {
+        const row = makeNotif();
+        assert.equal(markNotificationRead(row.id), true);
+    });
+    it("is idempotent — returns true even if already read", () => {
+        const row = makeNotif();
+        assert.equal(markNotificationRead(row.id), true);
+        assert.equal(markNotificationRead(row.id), true, "second call should still return true");
+    });
+    it("sets read_at on the row", () => {
+        const row = makeNotif();
+        markNotificationRead(row.id);
+        const updated = getDb()
+            .prepare("SELECT read_at FROM background_notifications WHERE id = ?")
+            .get(row.id);
+        assert.ok(updated.read_at, "read_at should be set after marking read");
+    });
+});
+// ── markAllNotificationsRead ─────────────────────────────────────────────────
+describe("markAllNotificationsRead", () => {
+    it("returns the count of newly-marked rows", () => {
+        makeNotif();
+        makeNotif();
+        makeNotif();
+        assert.equal(markAllNotificationsRead(), 3);
+    });
+    it("subsequent call returns 0 (all already read)", () => {
+        makeNotif();
+        makeNotif();
+        markAllNotificationsRead();
+        assert.equal(markAllNotificationsRead(), 0);
+    });
+    it("only marks unread rows — pre-read rows not re-touched", () => {
+        const a = makeNotif();
+        makeNotif();
+        markNotificationRead(a.id); // mark one manually first
+        const count = markAllNotificationsRead(); // should only mark the remaining 1
+        assert.equal(count, 1);
+    });
+});
+// ── listUnreadNotifications ──────────────────────────────────────────────────
+describe("listUnreadNotifications", () => {
+    it("excludes read rows", () => {
+        const a = makeNotif({ title: "A" });
+        const b = makeNotif({ title: "B" });
+        markNotificationRead(a.id);
+        const unread = listUnreadNotifications();
+        assert.ok(!unread.some((r) => r.id === a.id), "read row should not appear");
+        assert.ok(unread.some((r) => r.id === b.id), "unread row should appear");
+    });
+    it("returns newest first", () => {
+        const a = makeNotif({ title: "A" });
+        const b = makeNotif({ title: "B" });
+        const rows = listUnreadNotifications();
+        assert.equal(rows[0].id, b.id);
+        assert.equal(rows[1].id, a.id);
+    });
+    it("returns empty array when all are read", () => {
+        makeNotif();
+        makeNotif();
+        markAllNotificationsRead();
+        assert.deepEqual(listUnreadNotifications(), []);
+    });
+});
+// ── pruneOldNotifications ─────────────────────────────────────────────────────
+describe("pruneOldNotifications", () => {
+    it("deletes rows older than the threshold and returns the count", () => {
+        const old = makeNotif({ title: "Old" });
+        makeNotif({ title: "Recent" }); // stays untouched
+        // Back-date the 'old' row to 10 days ago
+        getDb()
+            .prepare("UPDATE background_notifications SET created_at = datetime('now', '-10 days') WHERE id = ?")
+            .run(old.id);
+        const deleted = pruneOldNotifications(7); // prune rows older than 7 days
+        assert.equal(deleted, 1, "should delete exactly the back-dated row");
+        const remaining = listRecentNotifications();
+        assert.ok(!remaining.some((r) => r.id === old.id), "old row should be gone");
+        assert.ok(remaining.some((r) => r.title === "Recent"), "recent row should remain");
+    });
+    it("returns 0 when nothing is old enough to prune", () => {
+        makeNotif();
+        makeNotif();
+        assert.equal(pruneOldNotifications(7), 0);
+    });
+    it("is safe on an empty table", () => {
+        assert.equal(pruneOldNotifications(1), 0);
+    });
+});
+//# sourceMappingURL=notifications.test.js.map

package/dist/store/schedule-runs.js

@@ -0,0 +1,46 @@
+import { getDb } from "./db.js";
+/** Create a new run in 'running' status. Returns the row. */
+export function startScheduleRun(input) {
+    const db = getDb();
+    const info = db
+        .prepare(`INSERT INTO schedule_runs (schedule_type, schedule_id, schedule_name, squad_slug)
+       VALUES (?, ?, ?, ?)`)
+        .run(input.schedule_type, input.schedule_id, input.schedule_name, input.squad_slug ?? null);
+    return db
+        .prepare("SELECT * FROM schedule_runs WHERE id = ?")
+        .get(info.lastInsertRowid);
+}
+/** Mark a run complete (success). Optionally link a notification_id. */
+export function completeScheduleRun(id, notificationId) {
+    getDb()
+        .prepare(`UPDATE schedule_runs
+       SET status = 'done', completed_at = CURRENT_TIMESTAMP, notification_id = ?
+       WHERE id = ?`)
+        .run(notificationId ?? null, id);
+}
+/** Mark a run failed with an error message. */
+export function failScheduleRun(id, errorText) {
+    getDb()
+        .prepare(`UPDATE schedule_runs
+       SET status = 'failed', completed_at = CURRENT_TIMESTAMP, error_text = ?
+       WHERE id = ?`)
+        .run(errorText, id);
+}
+/** Get last N runs for a specific schedule. Newest first. */
+export function getScheduleRuns(scheduleType, scheduleId, limit = 10) {
+    return getDb()
+        .prepare(`SELECT * FROM schedule_runs
+       WHERE schedule_type = ? AND schedule_id = ?
+       ORDER BY started_at DESC
+       LIMIT ?`)
+        .all(scheduleType, scheduleId, limit);
+}
+/** Prune runs older than the given number of days. Returns rows deleted. */
+export function pruneOldScheduleRuns(olderThanDays) {
+    const info = getDb()
+        .prepare(`DELETE FROM schedule_runs
+       WHERE started_at < datetime('now', '-' || ? || ' days')`)
+        .run(olderThanDays);
+    return info.changes;
+}
+//# sourceMappingURL=schedule-runs.js.map

package/dist/telegram/bot.js

@@ -141,4 +141,18 @@ export async function sendProactiveMessage(text) {
         }
     }
 }
+/**
+ * Send a background schedule result as a Telegram notification.
+ * Delegates to sendProactiveMessage for chunking, bot-not-configured guards,
+ * and authorized-user checks — no extra logic needed here.
+ *
+ * Format (plain text, no parse_mode):
+ *   🔔 Background update — <title>
+ *
+ *   <text>
+ */
+export async function sendBackgroundNotification(opts) {
+    const formatted = `\ud83d\udd14 Background update \u2014 ${opts.title}\n\n${opts.text}`;
+    await sendProactiveMessage(formatted);
+}
 //# sourceMappingURL=bot.js.map

package/dist/tui/index.js

@@ -17,6 +17,76 @@ Type a message to chat. Commands:
   /quit                — exit
 `;
 let verbose = false;
+// Held so printBackgroundNotification can redraw the prompt around notifications.
+// Assigned inside startTui(); undefined when running headless (no TUI).
+let activeInterface;
+const NOTIFICATION_MAX_LINES = 6;
+const NOTIFICATION_WRAP_WIDTH = 78;
+/** Hard-wrap a single line to at most `width` visible chars, returning segments. */
+function wrapLine(line, width) {
+    const segments = [];
+    while (line.length > width) {
+        segments.push(line.slice(0, width));
+        line = line.slice(width);
+    }
+    segments.push(line);
+    return segments;
+}
+/**
+ * Print a background notification in a bordered block above the prompt,
+ * preserving any in-progress readline input the user has typed.
+ *
+ * Format:
+ *   ╭─🔔 Background update: <title>
+ *   │ <line1>
+ *   │ […N more lines — see /notifications]   (if truncated)
+ *   ╰─
+ *
+ * Safe to call at any time, even before startTui(). Never throws.
+ */
+export function printBackgroundNotification(opts) {
+    try {
+        // Build display lines from text, hard-wrapping long lines.
+        const rawLines = opts.text.split(/\r?\n/);
+        const displayLines = [];
+        for (const raw of rawLines) {
+            for (const seg of wrapLine(raw, NOTIFICATION_WRAP_WIDTH)) {
+                displayLines.push(seg);
+            }
+        }
+        const truncated = displayLines.length > NOTIFICATION_MAX_LINES;
+        const visible = truncated ? displayLines.slice(0, NOTIFICATION_MAX_LINES) : displayLines;
+        const extra = displayLines.length - NOTIFICATION_MAX_LINES;
+        const top = "\u256d\u2500\ud83d\udd14 Background update: " + opts.title + "\n";
+        const body = visible.map((l) => "\u2502 " + l).join("\n");
+        const overflow = truncated
+            ? "\n\u2502 [\u2026" + extra + " more line" + (extra === 1 ? "" : "s") + " \u2014 see /notifications]"
+            : "";
+        const bottom = "\n\u2570\u2500\n";
+        const block = top + body + overflow + bottom;
+        if (!activeInterface) {
+            // Headless daemon — no readline interface live; plain log is fine.
+            process.stdout.write(block);
+            return;
+        }
+        // Capture whatever the user has typed so far.
+        // readline stores the pending input in `rl.line` (stable internal property).
+        const currentLine = activeInterface.line ?? "";
+        // Clear the current prompt+input line, print the notification, then
+        // redraw the prompt with the user's buffer.
+        process.stdout.write("\r\x1b[K");
+        process.stdout.write(block);
+        if (currentLine === "") {
+            activeInterface.prompt(true);
+        }
+        else {
+            process.stdout.write("io> " + currentLine);
+        }
+    }
+    catch (err) {
+        console.error("[io] printBackgroundNotification failed:", err instanceof Error ? err.message : String(err));
+    }
+}
 function renderActivity(taskIdArg) {
     const recent = listRecentTasks(20);
     let task = undefined;
@@ -62,6 +132,9 @@ export async function startTui() {
         input: process.stdin,
         output: process.stdout,
     });
+    // Keep a module-level reference so printBackgroundNotification can redraw
+    // the prompt without disturbing the user's in-progress input.
+    activeInterface = rl;
     console.log(WELCOME_BANNER);
     rl.setPrompt("io> ");
     rl.prompt();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heyio",
-  "version": "0.6.0",
+  "version": "0.9.0",
   "description": "IO — a personal AI assistant built on the GitHub Copilot SDK",
   "bin": {
     "io": "dist/index.js"
@@ -18,7 +18,8 @@
     "daemon": "tsx src/daemon.ts",
     "tui": "tsx src/tui/index.ts",
     "dev": "tsx --watch src/daemon.ts",
-    "prepublishOnly": "npm run build:all"
+    "prepublishOnly": "npm run build:all",
+    "test": "node --import tsx --test 'src/**/*.test.ts'"
   },
   "engines": {
     "node": ">=22"