heyio 0.1.0

package/dist/store/tasks.js

@@ -0,0 +1,32 @@
+import { getDb } from "./db.js";
+export function createTask(taskId, agentSlug, description, originChannel) {
+    const db = getDb();
+    db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, origin_channel) VALUES (?, ?, ?, ?)").run(taskId, agentSlug, description, originChannel ?? null);
+    return getTask(taskId);
+}
+export function getTask(taskId) {
+    return getDb()
+        .prepare("SELECT * FROM agent_tasks WHERE task_id = ?")
+        .get(taskId);
+}
+export function getActiveTasks() {
+    return getDb()
+        .prepare("SELECT * FROM agent_tasks WHERE status = 'running' ORDER BY started_at DESC")
+        .all();
+}
+export function completeTask(taskId, result) {
+    getDb()
+        .prepare("UPDATE agent_tasks SET status = 'done', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?")
+        .run(result, taskId);
+}
+export function failTask(taskId, error) {
+    getDb()
+        .prepare("UPDATE agent_tasks SET status = 'failed', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?")
+        .run(error, taskId);
+}
+export function clearStaleTasks() {
+    getDb()
+        .prepare("UPDATE agent_tasks SET status = 'failed', result = 'Marked stale on startup', completed_at = CURRENT_TIMESTAMP WHERE status = 'running'")
+        .run();
+}
+//# sourceMappingURL=tasks.js.map

package/dist/telegram/bot.js

@@ -0,0 +1,141 @@
+import { Bot } from "grammy";
+import { config } from "../config.js";
+const TELEGRAM_MAX_LENGTH = 4096;
+const EDIT_DEBOUNCE_MS = 500;
+let bot;
+let messageHandler;
+export function setMessageHandler(handler) {
+    messageHandler = handler;
+}
+export function createBot() {
+    if (!config.telegramBotToken) {
+        console.error("[io] Telegram bot token not configured");
+        return;
+    }
+    bot = new Bot(config.telegramBotToken);
+    bot.on("message:text", async (ctx) => {
+        const userId = ctx.from?.id;
+        if (config.authorizedUserId && userId !== config.authorizedUserId) {
+            return;
+        }
+        if (!messageHandler) {
+            console.error("[io] No message handler registered");
+            return;
+        }
+        const text = ctx.message.text;
+        const chatId = ctx.chat.id;
+        const messageId = ctx.message.message_id;
+        await ctx.replyWithChatAction("typing");
+        const placeholder = await ctx.reply("…");
+        let accumulated = "";
+        let lastEditTime = 0;
+        let pendingEdit;
+        const editReply = async (content) => {
+            try {
+                await ctx.api.editMessageText(chatId, placeholder.message_id, content);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                if (!message.includes("message is not modified")) {
+                    console.error("[io] Failed to edit message:", message);
+                }
+            }
+        };
+        try {
+            await messageHandler(text, chatId, messageId, (chunk, done) => {
+                accumulated += chunk;
+                if (done) {
+                    if (pendingEdit) {
+                        clearTimeout(pendingEdit);
+                        pendingEdit = undefined;
+                    }
+                    return;
+                }
+                const now = Date.now();
+                const timeSinceLastEdit = now - lastEditTime;
+                if (timeSinceLastEdit >= EDIT_DEBOUNCE_MS) {
+                    lastEditTime = now;
+                    void editReply(accumulated);
+                }
+                else if (!pendingEdit) {
+                    pendingEdit = setTimeout(() => {
+                        pendingEdit = undefined;
+                        lastEditTime = Date.now();
+                        void editReply(accumulated);
+                    }, EDIT_DEBOUNCE_MS - timeSinceLastEdit);
+                }
+            });
+            if (pendingEdit) {
+                clearTimeout(pendingEdit);
+            }
+            // Send final message
+            if (accumulated.length > 0) {
+                await editReply(accumulated);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error("[io] Error handling message:", message);
+            await editReply("An error occurred while processing your message.");
+        }
+    });
+    bot.catch((err) => {
+        console.error("[io] Grammy bot error:", err.message);
+    });
+    console.log("[io] Telegram bot created");
+}
+export async function startBot() {
+    if (!bot) {
+        console.error("[io] Bot not created — call createBot() first");
+        return;
+    }
+    try {
+        console.log("[io] Starting Telegram bot polling…");
+        void bot.start({
+            onStart: () => console.log("[io] Telegram bot polling started"),
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error("[io] Failed to start Telegram bot:", message);
+    }
+}
+export async function stopBot() {
+    if (!bot) {
+        return;
+    }
+    try {
+        await bot.stop();
+        console.log("[io] Telegram bot stopped");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error("[io] Error stopping Telegram bot:", message);
+    }
+}
+export async function sendProactiveMessage(text) {
+    if (!bot) {
+        console.error("[io] Bot not created — cannot send proactive message");
+        return;
+    }
+    if (!config.authorizedUserId) {
+        console.error("[io] No authorized user ID configured");
+        return;
+    }
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        chunks.push(remaining.slice(0, TELEGRAM_MAX_LENGTH));
+        remaining = remaining.slice(TELEGRAM_MAX_LENGTH);
+    }
+    for (const chunk of chunks) {
+        try {
+            await bot.api.sendMessage(config.authorizedUserId, chunk);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error("[io] Failed to send proactive message:", message);
+        }
+    }
+}
+//# sourceMappingURL=bot.js.map

package/dist/telegram/handlers.js

@@ -0,0 +1,4 @@
+export {};
+// Telegram command handlers — future expansion
+// Commands like /start, /help, /status will be added here
+//# sourceMappingURL=handlers.js.map

package/dist/tui/index.js

@@ -0,0 +1,79 @@
+import { createInterface } from "readline";
+let messageHandler;
+export function setMessageHandler(handler) {
+    messageHandler = handler;
+}
+const WELCOME_BANNER = `
+╔══════════════════════════════════════╗
+║          IO — AI Assistant           ║
+╚══════════════════════════════════════╝
+Type a message to chat. Commands:
+  /status  — show status
+  /quit    — exit
+`;
+function clearLine() {
+    process.stdout.write("\r\x1b[K");
+}
+export async function startTui() {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    console.log(WELCOME_BANNER);
+    rl.setPrompt("io> ");
+    rl.prompt();
+    rl.on("line", async (input) => {
+        const trimmed = input.trim();
+        if (!trimmed) {
+            rl.prompt();
+            return;
+        }
+        if (trimmed === "/quit") {
+            console.log("[io] Goodbye!");
+            rl.close();
+            process.exit(0);
+        }
+        if (trimmed === "/status") {
+            console.log(`[io] Uptime: ${Math.floor(process.uptime())}s`);
+            rl.prompt();
+            return;
+        }
+        if (!messageHandler) {
+            console.log("[io] No message handler registered.");
+            rl.prompt();
+            return;
+        }
+        // Show typing indicator
+        process.stdout.write("...");
+        let accumulated = "";
+        let firstChunk = true;
+        try {
+            await messageHandler(trimmed, (text, done) => {
+                if (firstChunk) {
+                    clearLine();
+                    firstChunk = false;
+                }
+                if (done) {
+                    clearLine();
+                    process.stdout.write(accumulated + "\n");
+                    rl.prompt();
+                }
+                else {
+                    accumulated += text;
+                    clearLine();
+                    process.stdout.write(accumulated);
+                }
+            });
+        }
+        catch (err) {
+            clearLine();
+            console.error(`[io] Error: ${err instanceof Error ? err.message : String(err)}`);
+            rl.prompt();
+        }
+    });
+    rl.on("close", () => {
+        console.log("\n[io] Goodbye!");
+        process.exit(0);
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/update.js

@@ -0,0 +1,53 @@
+import { execSync } from "child_process";
+const PACKAGE_NAME = "heyio";
+export async function checkForUpdate() {
+    try {
+        const packageJson = await import("../package.json", { with: { type: "json" } }).catch(() => null);
+        const current = packageJson?.default?.version ?? "0.0.0";
+        const latest = execSync(`npm view ${PACKAGE_NAME} version 2>/dev/null`, {
+            encoding: "utf-8",
+            timeout: 10_000,
+        }).trim();
+        if (!latest)
+            return { updateAvailable: false, current, latest: current };
+        const updateAvailable = latest !== current && compareSemver(current, latest) < 0;
+        return { updateAvailable, current, latest };
+    }
+    catch {
+        return { updateAvailable: false, current: "unknown", latest: "unknown" };
+    }
+}
+/**
+ * Auto-update: install the latest version globally and return true if updated.
+ * Returns false if already up-to-date or if the update fails.
+ */
+export async function autoUpdate() {
+    const info = await checkForUpdate();
+    if (!info.updateAvailable)
+        return false;
+    console.log(`[io] ⬆ Updating: v${info.current} → v${info.latest}...`);
+    try {
+        execSync(`npm install -g ${PACKAGE_NAME}@latest`, {
+            encoding: "utf-8",
+            timeout: 60_000,
+            stdio: "pipe",
+        });
+        console.log(`[io] ✓ Updated to v${info.latest}. Restarting...`);
+        return true;
+    }
+    catch (err) {
+        console.error(`[io] ⚠ Auto-update failed:`, err instanceof Error ? err.message : err);
+        return false;
+    }
+}
+function compareSemver(a, b) {
+    const pa = a.split(".").map(Number);
+    const pb = b.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+        const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+//# sourceMappingURL=update.js.map

package/dist/wiki/fs.js

@@ -0,0 +1,152 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync, openSync, fsyncSync, closeSync, } from "fs";
+import { join, resolve, relative, dirname, basename, extname } from "path";
+import { randomBytes } from "crypto";
+import { WIKI_DIR } from "../paths.js";
+export const PAGES_DIR = join(WIKI_DIR, "pages");
+export const SOURCES_DIR = join(WIKI_DIR, "sources");
+const INDEX_PATH = join(WIKI_DIR, "index.md");
+const LOG_PATH = join(WIKI_DIR, "log.md");
+const PAGE_CATEGORIES = ["preferences", "projects", "people", "general"];
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function resolvePath(relativePath) {
+    const full = resolve(WIKI_DIR, relativePath);
+    const rel = relative(WIKI_DIR, full);
+    if (rel.startsWith("..") || resolve(full) !== full) {
+        throw new Error(`Path traversal detected: ${relativePath}`);
+    }
+    return full;
+}
+function walkDir(dir) {
+    if (!existsSync(dir))
+        return [];
+    const results = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...walkDir(fullPath));
+        }
+        else {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+export function writeFileAtomic(fullPath, content) {
+    const dir = dirname(fullPath);
+    mkdirSync(dir, { recursive: true });
+    const tmp = join(dir, `.tmp-${randomBytes(6).toString("hex")}`);
+    const fd = openSync(tmp, "w");
+    try {
+        writeFileSync(fd, content, "utf-8");
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    renameSync(tmp, fullPath);
+}
+export function assertPagePath(relativePath) {
+    if (!relativePath.startsWith("pages/") && !relativePath.startsWith("pages\\")) {
+        throw new Error(`Page path must be under pages/: ${relativePath}`);
+    }
+    if (extname(relativePath) !== ".md") {
+        throw new Error(`Page path must end in .md: ${relativePath}`);
+    }
+    const full = resolve(WIKI_DIR, relativePath);
+    const rel = relative(WIKI_DIR, full);
+    if (rel.startsWith("..") || !rel.startsWith("pages")) {
+        throw new Error(`Path traversal detected: ${relativePath}`);
+    }
+}
+export function ensureWikiStructure() {
+    const created = !existsSync(WIKI_DIR);
+    mkdirSync(WIKI_DIR, { recursive: true });
+    mkdirSync(PAGES_DIR, { recursive: true });
+    mkdirSync(SOURCES_DIR, { recursive: true });
+    for (const cat of PAGE_CATEGORIES) {
+        mkdirSync(join(PAGES_DIR, cat), { recursive: true });
+    }
+    if (!existsSync(INDEX_PATH)) {
+        writeFileAtomic(INDEX_PATH, "# Wiki Index\n\n_No pages yet._\n");
+    }
+    if (!existsSync(LOG_PATH)) {
+        writeFileAtomic(LOG_PATH, "# Wiki Log\n\n_No operations recorded._\n");
+    }
+    return created;
+}
+export function readPage(relativePath) {
+    const full = resolvePath(relativePath);
+    if (!existsSync(full))
+        return undefined;
+    return readFileSync(full, "utf-8");
+}
+export function writePage(relativePath, content) {
+    assertPagePath(relativePath);
+    const full = resolvePath(relativePath);
+    writeFileAtomic(full, content);
+}
+export function deletePage(relativePath) {
+    assertPagePath(relativePath);
+    const full = resolvePath(relativePath);
+    if (!existsSync(full))
+        return false;
+    unlinkSync(full);
+    return true;
+}
+export function pageExists(relativePath) {
+    assertPagePath(relativePath);
+    const full = resolvePath(relativePath);
+    return existsSync(full);
+}
+export function listPages() {
+    return walkDir(PAGES_DIR)
+        .filter((f) => extname(f) === ".md")
+        .map((f) => relative(WIKI_DIR, f).replace(/\\/g, "/"));
+}
+export function writeRawSource(name, content) {
+    const sanitized = basename(name).replace(/[^a-zA-Z0-9._-]/g, "_");
+    if (!sanitized)
+        throw new Error(`Invalid source name: ${name}`);
+    const full = join(SOURCES_DIR, sanitized);
+    writeFileAtomic(full, content);
+}
+export function readRawSource(name) {
+    const sanitized = basename(name).replace(/[^a-zA-Z0-9._-]/g, "_");
+    const full = join(SOURCES_DIR, sanitized);
+    if (!existsSync(full))
+        return undefined;
+    return readFileSync(full, "utf-8");
+}
+export function listSources() {
+    if (!existsSync(SOURCES_DIR))
+        return [];
+    return readdirSync(SOURCES_DIR).filter((f) => {
+        const full = join(SOURCES_DIR, f);
+        return statSync(full).isFile();
+    });
+}
+export function readIndexFile() {
+    if (!existsSync(INDEX_PATH))
+        return "";
+    return readFileSync(INDEX_PATH, "utf-8");
+}
+export function writeIndexFile(content) {
+    writeFileAtomic(INDEX_PATH, content);
+}
+export function readLogFile() {
+    if (!existsSync(LOG_PATH))
+        return "";
+    return readFileSync(LOG_PATH, "utf-8");
+}
+export function writeLogFile(content) {
+    writeFileAtomic(LOG_PATH, content);
+}
+export function getWikiDir() {
+    return WIKI_DIR;
+}
+//# sourceMappingURL=fs.js.map

package/dist/wiki/search.js

@@ -0,0 +1,49 @@
+import { readPage, listPages } from "./fs.js";
+export function searchWiki(query) {
+    if (!query.trim())
+        return [];
+    const lowerQuery = query.toLowerCase();
+    const pages = listPages();
+    const results = [];
+    for (const pagePath of pages) {
+        const content = readPage(pagePath);
+        if (!content)
+            continue;
+        const lowerContent = content.toLowerCase();
+        const idx = lowerContent.indexOf(lowerQuery);
+        if (idx === -1)
+            continue;
+        const title = extractTitle(pagePath, content);
+        const snippetStart = Math.max(0, idx - 100);
+        const snippetEnd = Math.min(content.length, idx + query.length + 100);
+        let snippet = content.slice(snippetStart, snippetEnd).trim();
+        if (snippetStart > 0)
+            snippet = `…${snippet}`;
+        if (snippetEnd < content.length)
+            snippet = `${snippet}…`;
+        results.push({ path: pagePath, title, snippet });
+    }
+    return results;
+}
+export function getWikiSummary() {
+    const pages = listPages();
+    if (pages.length === 0)
+        return "Wiki is empty — no pages yet.";
+    const lines = ["Wiki pages:"];
+    for (const pagePath of pages) {
+        const content = readPage(pagePath);
+        const title = content ? extractTitle(pagePath, content) : pagePath;
+        lines.push(`- ${pagePath}: ${title}`);
+    }
+    return lines.join("\n");
+}
+function extractTitle(pagePath, content) {
+    const firstLine = content.split("\n").find((l) => l.trim().length > 0);
+    if (firstLine) {
+        const heading = firstLine.replace(/^#+\s*/, "").trim();
+        if (heading)
+            return heading;
+    }
+    return pagePath.replace(/.*\//, "").replace(/\.md$/, "");
+}
+//# sourceMappingURL=search.js.map

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "heyio",
+  "version": "0.1.0",
+  "description": "IO — a personal AI assistant built on the GitHub Copilot SDK",
+  "bin": {
+    "io": "dist/index.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "daemon": "tsx src/daemon.ts",
+    "tui": "tsx src/tui/index.ts",
+    "dev": "tsx --watch src/daemon.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "type": "module",
+  "keywords": [
+    "copilot",
+    "telegram",
+    "orchestrator",
+    "ai",
+    "cli",
+    "assistant"
+  ],
+  "author": "Michael Jolley",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/michaeljolley/io.git"
+  },
+  "homepage": "https://github.com/michaeljolley/io#readme",
+  "dependencies": {
+    "@github/copilot-sdk": "^0.2.2",
+    "better-sqlite3": "^12.6.2",
+    "commander": "^14.0.0",
+    "dotenv": "^17.3.1",
+    "express": "^5.2.1",
+    "grammy": "^1.40.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.3.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}