heyio 0.1.0

package/dist/copilot/orchestrator.js

@@ -0,0 +1,354 @@
+import { approveAll, } from "@github/copilot-sdk";
+import { config } from "../config.js";
+import { SESSIONS_DIR } from "../paths.js";
+import { getState, setState, deleteState, logConversation } from "../store/db.js";
+import { clearStaleTasks } from "../store/tasks.js";
+import { getSquad, listSquads, createSquad, logDecision, getDecisionsSummary, updateSquadStatus, } from "../store/squads.js";
+import { readPage, writePage, assertPagePath } from "../wiki/fs.js";
+import { searchWiki, getWikiSummary } from "../wiki/search.js";
+import { getOrchestratorSystemMessage } from "./system-message.js";
+import { createTools } from "./tools.js";
+import { getSkillDirectories } from "./skills.js";
+import { resetClient } from "./client.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const HEALTH_CHECK_INTERVAL_MS = 30_000;
+const SEND_TIMEOUT_MS = 600_000;
+const MAX_RETRIES = 3;
+const SESSION_ID_KEY = "orchestrator_session_id";
+// ---------------------------------------------------------------------------
+// Module state
+// ---------------------------------------------------------------------------
+let client;
+let orchestratorSession;
+let healthCheckTimer;
+let sessionInitPromise;
+let clientResetPromise;
+const messageQueue = [];
+let processing = false;
+// ---------------------------------------------------------------------------
+// Session config helpers
+// ---------------------------------------------------------------------------
+function mapSquad(s) {
+    return { slug: s.slug, name: s.name, projectPath: s.project_path, status: s.status };
+}
+function getToolDeps() {
+    return {
+        wikiRead: readPage,
+        wikiWrite: writePage,
+        wikiSearch: searchWiki,
+        wikiAssertPagePath: assertPagePath,
+        getSquad: (slug) => {
+            const s = getSquad(slug);
+            return s ? mapSquad(s) : undefined;
+        },
+        listSquads: () => listSquads().map(mapSquad),
+        createSquad,
+        logDecision,
+        getDecisionsSummary,
+        updateSquadStatus,
+    };
+}
+function getSessionConfig() {
+    const tools = createTools(getToolDeps());
+    return { tools, skillDirectories: getSkillDirectories() };
+}
+function buildFullSessionConfig() {
+    const { tools, skillDirectories } = getSessionConfig();
+    return {
+        model: config.defaultModel || "gpt-4.1",
+        configDir: SESSIONS_DIR,
+        streaming: true,
+        systemMessage: {
+            content: getOrchestratorSystemMessage({
+                selfEditEnabled: config.selfEditEnabled,
+                memorySummary: getWikiSummary() || undefined,
+            }),
+        },
+        tools,
+        skillDirectories,
+        onPermissionRequest: approveAll,
+        infiniteSessions: {
+            enabled: true,
+            backgroundCompactionThreshold: 0.80,
+            bufferExhaustionThreshold: 0.95,
+        },
+    };
+}
+function buildResumeConfig() {
+    const { tools, skillDirectories } = getSessionConfig();
+    return {
+        configDir: SESSIONS_DIR,
+        streaming: true,
+        tools,
+        skillDirectories,
+        onPermissionRequest: approveAll,
+        infiniteSessions: {
+            enabled: true,
+            backgroundCompactionThreshold: 0.80,
+            bufferExhaustionThreshold: 0.95,
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Error classification
+// ---------------------------------------------------------------------------
+function isConnectionError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const msg = err.message.toLowerCase();
+    return (msg.includes("disconnect") ||
+        msg.includes("epipe") ||
+        msg.includes("econnreset") ||
+        msg.includes("econnrefused") ||
+        msg.includes("connection") ||
+        msg.includes("socket"));
+}
+function isSessionError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const msg = err.message.toLowerCase();
+    return (msg.includes("session") ||
+        msg.includes("closed") ||
+        msg.includes("expired") ||
+        msg.includes("not found"));
+}
+// ---------------------------------------------------------------------------
+// Client management
+// ---------------------------------------------------------------------------
+async function ensureClient() {
+    if (!client) {
+        throw new Error("Orchestrator not initialized — call initOrchestrator first");
+    }
+    if (client.getState() === "connected")
+        return client;
+    // Coalesce concurrent reset attempts
+    if (clientResetPromise)
+        return clientResetPromise;
+    clientResetPromise = (async () => {
+        console.error("[io] Client disconnected, resetting…");
+        try {
+            const newClient = await resetClient();
+            client = newClient;
+            return newClient;
+        }
+        finally {
+            clientResetPromise = undefined;
+        }
+    })();
+    return clientResetPromise;
+}
+// ---------------------------------------------------------------------------
+// Session management
+// ---------------------------------------------------------------------------
+async function ensureOrchestratorSession() {
+    if (orchestratorSession)
+        return orchestratorSession;
+    // Coalesce concurrent session creation
+    if (sessionInitPromise)
+        return sessionInitPromise;
+    sessionInitPromise = (async () => {
+        try {
+            const c = await ensureClient();
+            const savedSessionId = getState(SESSION_ID_KEY);
+            if (savedSessionId) {
+                try {
+                    console.error("[io] Resuming session:", savedSessionId);
+                    const session = await c.resumeSession(savedSessionId, buildResumeConfig());
+                    orchestratorSession = session;
+                    return session;
+                }
+                catch (err) {
+                    console.error("[io] Failed to resume session, creating new one:", err instanceof Error ? err.message : err);
+                    deleteState(SESSION_ID_KEY);
+                }
+            }
+            console.error("[io] Creating new orchestrator session");
+            const session = await c.createSession(buildFullSessionConfig());
+            setState(SESSION_ID_KEY, session.sessionId);
+            orchestratorSession = session;
+            return session;
+        }
+        finally {
+            sessionInitPromise = undefined;
+        }
+    })();
+    return sessionInitPromise;
+}
+function invalidateSession() {
+    orchestratorSession = undefined;
+    sessionInitPromise = undefined;
+}
+// ---------------------------------------------------------------------------
+// Message execution
+// ---------------------------------------------------------------------------
+async function executeOnSession(prompt, callback) {
+    const session = await ensureOrchestratorSession();
+    let accumulated = "";
+    const unsubDelta = session.on("assistant.message_delta", (event) => {
+        accumulated += event.data.deltaContent;
+        callback(accumulated, false);
+    });
+    try {
+        const result = await session.sendAndWait({ prompt }, SEND_TIMEOUT_MS);
+        unsubDelta();
+        const finalText = result?.data.content ?? accumulated;
+        callback(finalText, true);
+        return finalText;
+    }
+    catch (err) {
+        unsubDelta();
+        // If we accumulated partial text, return it gracefully on timeout
+        if (accumulated && err instanceof Error && err.message.includes("timeout")) {
+            console.error("[io] Session sendAndWait timed out, returning partial response");
+            callback(accumulated, true);
+            return accumulated;
+        }
+        // Session-level errors: invalidate and let caller retry
+        if (isSessionError(err)) {
+            console.error("[io] Session error, invalidating:", err instanceof Error ? err.message : err);
+            invalidateSession();
+        }
+        throw err;
+    }
+}
+// ---------------------------------------------------------------------------
+// Queue processing
+// ---------------------------------------------------------------------------
+function sourceTag(source) {
+    switch (source.type) {
+        case "telegram":
+            return "[via telegram]";
+        case "tui":
+            return "[via tui]";
+        case "background":
+            return "[via background]";
+    }
+}
+function sourceLabel(source) {
+    switch (source.type) {
+        case "telegram":
+            return "telegram";
+        case "tui":
+            return "tui";
+        case "background":
+            return "background";
+    }
+}
+async function processQueue() {
+    if (processing)
+        return;
+    processing = true;
+    try {
+        while (messageQueue.length > 0) {
+            const msg = messageQueue.shift();
+            const taggedPrompt = `${sourceTag(msg.source)} ${msg.prompt}`;
+            let lastError;
+            for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+                try {
+                    const response = await executeOnSession(taggedPrompt, msg.callback);
+                    logConversation("assistant", response, sourceLabel(msg.source));
+                    msg.resolve();
+                    lastError = undefined;
+                    break;
+                }
+                catch (err) {
+                    lastError = err instanceof Error ? err : new Error(String(err));
+                    console.error(`[io] Attempt ${attempt}/${MAX_RETRIES} failed:`, lastError.message);
+                    if (isConnectionError(err)) {
+                        // Reset client and invalidate session for connection errors
+                        invalidateSession();
+                        try {
+                            await ensureClient();
+                        }
+                        catch (resetErr) {
+                            console.error("[io] Client reset failed:", resetErr instanceof Error ? resetErr.message : resetErr);
+                        }
+                    }
+                    else if (isSessionError(err)) {
+                        // Session already invalidated in executeOnSession
+                    }
+                    else if (attempt === MAX_RETRIES) {
+                        // Non-retryable error on last attempt
+                        break;
+                    }
+                }
+            }
+            if (lastError) {
+                const errorMsg = `Sorry, I encountered an error: ${lastError.message}`;
+                msg.callback(errorMsg, true);
+                msg.reject(lastError);
+            }
+        }
+    }
+    finally {
+        processing = false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+export async function initOrchestrator(copilotClient) {
+    client = copilotClient;
+    clearStaleTasks();
+    // Validate the configured model
+    try {
+        const models = await copilotClient.listModels();
+        const defaultModel = config.defaultModel || "gpt-4.1";
+        const modelIds = models.map((m) => m.id);
+        if (!modelIds.includes(defaultModel)) {
+            console.error(`[io] Configured model "${defaultModel}" not found. Available: ${modelIds.join(", ")}`);
+        }
+        else {
+            console.error(`[io] Model validated: ${defaultModel}`);
+        }
+    }
+    catch (err) {
+        console.error("[io] Could not validate models:", err instanceof Error ? err.message : err);
+    }
+    // Start health check timer
+    healthCheckTimer = setInterval(() => {
+        if (!client || client.getState() !== "connected") {
+            console.error("[io] Health check: client disconnected, reconnecting…");
+            ensureClient().catch((err) => {
+                console.error("[io] Health check reconnect failed:", err instanceof Error ? err.message : err);
+            });
+            invalidateSession();
+        }
+    }, HEALTH_CHECK_INTERVAL_MS);
+    // Eagerly create/resume the session
+    try {
+        await ensureOrchestratorSession();
+        console.error("[io] Orchestrator session ready");
+    }
+    catch (err) {
+        console.error("[io] Eager session creation failed (will retry on first message):", err instanceof Error ? err.message : err);
+    }
+}
+export async function sendToOrchestrator(prompt, source, callback) {
+    logConversation("user", prompt, sourceLabel(source));
+    return new Promise((resolve, reject) => {
+        messageQueue.push({ prompt, source, callback, resolve, reject });
+        processQueue();
+    });
+}
+export async function shutdownOrchestrator() {
+    if (healthCheckTimer) {
+        clearInterval(healthCheckTimer);
+        healthCheckTimer = undefined;
+    }
+    if (orchestratorSession) {
+        try {
+            await orchestratorSession.disconnect();
+        }
+        catch (err) {
+            console.error("[io] Error disconnecting session:", err instanceof Error ? err.message : err);
+        }
+        orchestratorSession = undefined;
+    }
+    sessionInitPromise = undefined;
+    clientResetPromise = undefined;
+    client = undefined;
+}
+//# sourceMappingURL=orchestrator.js.map

package/dist/copilot/skills.js

@@ -0,0 +1,132 @@
+import { existsSync, readdirSync, readFileSync, rmSync, statSync } from "fs";
+import { join, basename } from "path";
+import { execSync } from "child_process";
+import { SKILLS_DIR } from "../paths.js";
+/**
+ * Scan SKILLS_DIR for subdirectories that contain a SKILL.md file.
+ * Returns absolute paths to qualifying skill directories.
+ */
+export function getSkillDirectories() {
+    if (!existsSync(SKILLS_DIR))
+        return [];
+    const dirs = [];
+    for (const entry of readdirSync(SKILLS_DIR)) {
+        const skillDir = join(SKILLS_DIR, entry);
+        if (!statSync(skillDir).isDirectory())
+            continue;
+        const skillMd = join(skillDir, "SKILL.md");
+        if (!existsSync(skillMd))
+            continue;
+        dirs.push(skillDir);
+        // Check for an agents subdirectory (Copilot SDK custom agents)
+        const agentsDir = join(skillDir, "agents");
+        if (existsSync(agentsDir) && statSync(agentsDir).isDirectory()) {
+            dirs.push(agentsDir);
+        }
+    }
+    return dirs;
+}
+function parseSkillMd(content) {
+    const lines = content.split(/\r?\n/);
+    let name = "";
+    let description = "";
+    let foundHeading = false;
+    const descLines = [];
+    for (const line of lines) {
+        if (!foundHeading) {
+            const match = line.match(/^#\s+(.+)/);
+            if (match) {
+                name = match[1].trim();
+                foundHeading = true;
+            }
+            continue;
+        }
+        // Skip blank lines between heading and first paragraph
+        if (descLines.length === 0 && line.trim() === "")
+            continue;
+        // Stop at the next blank line after collecting description text
+        if (descLines.length > 0 && line.trim() === "")
+            break;
+        // Stop at another heading
+        if (line.match(/^#+\s/))
+            break;
+        descLines.push(line.trim());
+    }
+    description = descLines.join(" ");
+    return { name, description };
+}
+/**
+ * List all installed skills with metadata parsed from their SKILL.md files.
+ */
+export function listSkills() {
+    if (!existsSync(SKILLS_DIR))
+        return [];
+    const skills = [];
+    for (const entry of readdirSync(SKILLS_DIR)) {
+        const skillDir = join(SKILLS_DIR, entry);
+        if (!statSync(skillDir).isDirectory())
+            continue;
+        const skillMdPath = join(skillDir, "SKILL.md");
+        if (!existsSync(skillMdPath))
+            continue;
+        const content = readFileSync(skillMdPath, "utf-8");
+        const { name, description } = parseSkillMd(content);
+        skills.push({
+            name: name || entry,
+            slug: entry,
+            description,
+            path: skillDir,
+        });
+    }
+    return skills;
+}
+/**
+ * Clone a git repo into SKILLS_DIR and return the installed skill info.
+ * Throws if the cloned repo does not contain a SKILL.md file.
+ */
+export async function installSkill(repoUrl) {
+    const repoName = basename(repoUrl, ".git").replace(/\.git$/, "");
+    const destDir = join(SKILLS_DIR, repoName);
+    execSync(`git clone ${repoUrl} ${destDir}`, { stdio: "pipe" });
+    const skillMdPath = join(destDir, "SKILL.md");
+    if (!existsSync(skillMdPath)) {
+        rmSync(destDir, { recursive: true, force: true });
+        throw new Error(`Repository "${repoUrl}" does not contain a SKILL.md file.`);
+    }
+    const content = readFileSync(skillMdPath, "utf-8");
+    const { name, description } = parseSkillMd(content);
+    return {
+        name: name || repoName,
+        slug: repoName,
+        description,
+        path: destDir,
+    };
+}
+/**
+ * Remove a skill directory by its slug. Returns true if it existed.
+ */
+export function removeSkill(slug) {
+    const skillDir = join(SKILLS_DIR, slug);
+    if (!existsSync(skillDir))
+        return false;
+    rmSync(skillDir, { recursive: true, force: true });
+    return true;
+}
+/**
+ * Search the skills registry for skills matching the given query.
+ * Returns an empty array on network or parsing errors.
+ */
+export async function searchSkillsRegistry(query) {
+    try {
+        const url = `https://skills.sh/api/search?q=${encodeURIComponent(query)}`;
+        const response = await fetch(url);
+        if (!response.ok)
+            return [];
+        const data = (await response.json());
+        return Array.isArray(data) ? data : [];
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=skills.js.map

package/dist/copilot/system-message.js

@@ -0,0 +1,90 @@
+import { config } from "../config.js";
+export function getOrchestratorSystemMessage(opts) {
+    const memoryBlock = opts?.memorySummary
+        ? `\n## Memory\nYou have a persistent knowledge base. Here's what you currently know:\n\n${opts.memorySummary}\n`
+        : "\n## Memory\nYou have a persistent knowledge base (wiki). It's currently empty — use `wiki_write` to start building it!\n";
+    const selfEditBlock = opts?.selfEditEnabled
+        ? ""
+        : `\n## Self-Edit Protection
+
+**You must NEVER modify your own source code.** This includes the IO codebase, configuration files in the project repo, or any file that is part of the IO application itself.
+
+If the user asks you to modify your own code, politely decline and explain that self-editing is disabled for safety. Suggest they make the changes manually or start IO with \`--self-edit\` to temporarily allow it.
+
+This restriction does NOT apply to:
+- User project files (code the user asks you to work on)
+- Skills in ~/.io/skills/ (user data)
+- The ~/.io/config.json file
+- Any files outside the IO installation directory
+`;
+    const squadBlock = opts?.squadRoster
+        ? `\n### Active Squads\n${opts.squadRoster}\n`
+        : "";
+    const osName = process.platform === "darwin" ? "macOS"
+        : process.platform === "win32" ? "Windows"
+            : "Linux";
+    return `You are IO, a personal AI assistant for developers running 24/7 on the user's machine (${osName}). You are an always-on assistant daemon.
+
+## Your Architecture
+
+You are a Node.js daemon process built with the Copilot SDK. Here's how you work:
+
+- **Telegram bot**: Messages arrive tagged with \`[via telegram]\`. Keep responses concise and mobile-friendly.
+- **Local TUI**: A terminal interface on the local machine. Messages arrive tagged with \`[via tui]\`. You can be more verbose here.
+- **Background tasks**: Messages tagged \`[via background]\` are results from squad workers you delegated to.
+- **HTTP API**: You expose a local API on port ${config.apiPort} for programmatic access.
+
+When no source tag is present, assume TUI.
+
+## Your Capabilities
+
+1. **Direct conversation**: Answer questions, discuss problems — no tools needed.
+2. **Squad system**: You can create project squads — persistent teams of specialized agents for specific projects. Each squad remembers its decisions and context.
+3. **Knowledge base**: You have a wiki-style knowledge base. Proactively save user preferences, project details, and important facts.
+4. **Shell access**: You can run shell commands on the user's machine.
+5. **Skills**: You have a modular skill system. Skills teach you how to use external tools.
+
+## Your Role
+
+You receive messages and decide how to handle them:
+
+- **Direct answer**: For simple questions, general knowledge, status checks — answer directly.
+- **Use tools**: For tasks requiring shell access, file operations, web lookups — use your tools.
+- **Create/delegate to squad**: For coding projects that need persistent context — create a squad with specialized agents.
+- **Use a skill**: If you have a skill for the task, use it.
+${squadBlock}
+## Squad System
+
+Squads are persistent project teams. When a user works on a codebase:
+1. Create a squad with \`squad_create\` — this sets up a persistent team for that project.
+2. The squad remembers decisions via \`squad_log_decision\`.
+3. Recall squad context with \`squad_recall\` before doing project work.
+4. Check squad status with \`squad_status\`.
+
+## Tool Usage
+
+### Knowledge Base
+- \`wiki_read\`: Read a page from your knowledge base.
+- \`wiki_write\`: Write or update a page. Use for preferences, project notes, facts.
+- \`wiki_search\`: Search your knowledge base.
+
+### Squad Management
+- \`squad_create\`: Create a project squad.
+- \`squad_recall\`: Get a squad's context and decisions.
+- \`squad_status\`: Check squad status.
+- \`squad_log_decision\`: Log a decision for a squad.
+
+### System
+- \`shell\`: Run a shell command.
+- \`web_fetch\`: Fetch a URL and return content.
+
+## Guidelines
+
+1. **Adapt to the channel**: On Telegram, be brief. On TUI, be detailed.
+2. **Proactive knowledge building**: When the user shares preferences or project details, save them to your wiki.
+3. Be conversational and helpful. You're IO.
+4. When a task fails, report the error clearly and suggest next steps.
+5. Expand shorthand paths: "~/dev/myapp" → the user's home directory + path.
+${selfEditBlock}${memoryBlock}`;
+}
+//# sourceMappingURL=system-message.js.map