heyio 0.42.1 → 1.0.1

package/dist/copilot/client.js

@@ -2,17 +2,7 @@ import { CopilotClient } from "@github/copilot-sdk";
 let client;
 export async function getClient() {
     if (!client) {
-        const opts = {
-            autoStart: true,
-        };
-        // Pass explicit token if available (env vars are also auto-detected by the SDK)
-        const token = process.env.COPILOT_GITHUB_TOKEN
-            || process.env.GH_TOKEN
-            || process.env.GITHUB_TOKEN;
-        if (token) {
-            opts.githubToken = token;
-        }
-        client = new CopilotClient(opts);
+        client = new CopilotClient();
         await client.start();
     }
     return client;
@@ -22,15 +12,14 @@ export async function resetClient() {
         try {
             await client.stop();
         }
-        catch { /* best-effort */ }
+        catch {
+            // ignore stop errors during reset
+        }
         client = undefined;
     }
     return getClient();
 }
-export async function stopClient() {
-    if (client) {
-        await client.stop();
-        client = undefined;
-    }
+export function getClientInstance() {
+    return client;
 }
 //# sourceMappingURL=client.js.map

package/dist/copilot/io-scheduler.js

@@ -1,155 +1,71 @@
-// IO-level scheduler — fires recurring tasks for IO itself, independent of
-// any squad. Mirrors the squad scheduler in shape (TICK_MS loop, in-flight
-// guard, reconcile on startup) but dispatches into the orchestrator via
-// sendToOrchestrator with a `background` source so IO can handle the prompt
-// the same way it handles any other user message.
-import { listIoSchedules, listDueIoSchedules, recordIoScheduleRun, setIoScheduleTimestamps, updateIoScheduleNextRun, } from "../store/io-schedules.js";
+import { listSchedules, updateScheduleLastRun } from "../store/schedules.js";
 import { sendToOrchestrator } from "./orchestrator.js";
-import { nextRun } from "./cron.js";
-import { notifyBackground } from "../notify.js";
-import { startScheduleRun, completeScheduleRun, failScheduleRun } from "../store/schedule-runs.js";
-const TICK_MS = 30_000;
-let timer;
-const inFlight = new Set();
-function buildPrompt(schedule) {
-    const header = `# Scheduled task: ${schedule.name}\n\n_This prompt was fired automatically by the IO scheduler. Cron expression: \`${schedule.cron_expr}\`._`;
-    const notes = schedule.notes
-        ? `\n\n**Operator notes:** ${schedule.notes}`
-        : "";
-    return `${header}\n\n${schedule.prompt}${notes}`;
+let ioSchedulerInterval;
+export function startIoScheduler() {
+    ioSchedulerInterval = setInterval(() => {
+        checkIoSchedules();
+    }, 60_000);
+    ioSchedulerInterval.unref();
 }
-async function fireSchedule(schedule) {
-    if (inFlight.has(schedule.id))
-        return;
-    inFlight.add(schedule.id);
-    const ranAt = new Date();
-    let nextIso = null;
-    try {
-        nextIso = nextRun(schedule.cron_expr, ranAt).toISOString();
-    }
-    catch (err) {
-        console.error(`[io] io-scheduler: cron parse error for schedule ${schedule.id}:`, err instanceof Error ? err.message : err);
-    }
-    recordIoScheduleRun(schedule.id, ranAt, nextIso);
-    console.log(`[io] io-scheduler: firing schedule "${schedule.name}" (next run: ${nextIso ?? "never"})`);
-    const run = startScheduleRun({
-        schedule_type: "io",
-        schedule_id: schedule.id,
-        schedule_name: schedule.name,
-    });
-    try {
-        let buffer = "";
-        await sendToOrchestrator(buildPrompt(schedule), { type: "background" }, (text, done) => {
-            buffer += text;
+function checkIoSchedules() {
+    const schedules = listSchedules("io");
+    const now = new Date();
+    for (const schedule of schedules) {
+        if (!schedule.enabled)
+            continue;
+        if (!isDue(schedule.cron, schedule.last_run, now))
+            continue;
+        updateScheduleLastRun(schedule.id);
+        sendToOrchestrator(schedule.prompt, "io-scheduler", (_text, done) => {
             if (done) {
-                void notifyBackground({
-                    source: {
-                        type: "io-schedule",
-                        scheduleId: schedule.id,
-                        scheduleName: schedule.name,
-                    },
-                    title: `IO schedule: ${schedule.name}`,
-                    text: buffer.trim(),
-                }).then((notifyResult) => {
-                    completeScheduleRun(run.id, notifyResult.id);
-                }).catch((err) => {
-                    failScheduleRun(run.id, err instanceof Error ? err.message : String(err));
-                });
+                console.log(`[io-scheduler] Schedule ${schedule.id} completed.`);
             }
         });
     }
-    catch (err) {
-        failScheduleRun(run.id, err instanceof Error ? err.message : String(err));
-        console.error(`[io] io-scheduler: failed to dispatch schedule ${schedule.id}:`, err instanceof Error ? err.message : err);
-    }
-    finally {
-        inFlight.delete(schedule.id);
-    }
 }
-async function tick() {
-    let due;
-    try {
-        due = listDueIoSchedules(new Date());
+function isDue(cron, lastRun, now) {
+    const parts = cron.split(" ");
+    if (parts.length !== 5)
+        return false;
+    const [minSpec, hourSpec, daySpec, monthSpec, weekdaySpec] = parts;
+    if (!matchesCronField(minSpec, now.getMinutes()))
+        return false;
+    if (!matchesCronField(hourSpec, now.getHours()))
+        return false;
+    if (!matchesCronField(daySpec, now.getDate()))
+        return false;
+    if (!matchesCronField(monthSpec, now.getMonth() + 1))
+        return false;
+    if (!matchesCronField(weekdaySpec, now.getDay()))
+        return false;
+    if (lastRun) {
+        const lastDate = new Date(lastRun);
+        const diffMs = now.getTime() - lastDate.getTime();
+        if (diffMs < 60_000)
+            return false;
     }
-    catch (err) {
-        console.error("[io] io-scheduler tick failed:", err instanceof Error ? err.message : err);
-        return;
+    return true;
+}
+function matchesCronField(spec, value) {
+    if (spec === "*")
+        return true;
+    if (spec.includes("-")) {
+        const [start, end] = spec.split("-").map(Number);
+        return value >= start && value <= end;
     }
-    for (const s of due) {
-        await fireSchedule(s);
+    if (spec.includes(",")) {
+        return spec.split(",").map(Number).includes(value);
     }
-}
-/**
- * Backfill next_run_at for any IO schedules that are NULL or stale. We
- * advance to the next future occurrence rather than replaying missed runs
- * — same semantics as the squad scheduler.
- */
-export function reconcileIoSchedules(now = new Date()) {
-    for (const s of listIoSchedules()) {
-        if (!s.enabled)
-            continue;
-        let needsUpdate = false;
-        if (!s.next_run_at) {
-            needsUpdate = true;
-        }
-        else {
-            const next = new Date(s.next_run_at);
-            if (Number.isNaN(next.getTime()) || next <= now)
-                needsUpdate = true;
-        }
-        if (!needsUpdate)
-            continue;
-        try {
-            const next = nextRun(s.cron_expr, now);
-            updateIoScheduleNextRun(s.id, next.toISOString());
-        }
-        catch (err) {
-            console.error(`[io] io-scheduler: invalid cron "${s.cron_expr}" on schedule ${s.id}; clearing next_run_at:`, err instanceof Error ? err.message : err);
-            updateIoScheduleNextRun(s.id, null);
-        }
+    if (spec.startsWith("*/")) {
+        const step = parseInt(spec.slice(2), 10);
+        return value % step === 0;
     }
-}
-export function startIoScheduler() {
-    if (timer)
-        return;
-    reconcileIoSchedules();
-    timer = setInterval(() => {
-        void tick();
-    }, TICK_MS);
-    // Don't keep the event loop alive on shutdown
-    timer.unref?.();
+    return parseInt(spec, 10) === value;
 }
 export function stopIoScheduler() {
-    if (timer) {
-        clearInterval(timer);
-        timer = undefined;
-    }
-}
-/**
- * Force a schedule to run immediately. Used by the `schedule_run_now` tool.
- *
- * The regular tick path (`fireSchedule`) advances `last_run_at` and
- * `next_run_at` as a side effect, which is correct for an automatic firing
- * but is the wrong behaviour for a manual one — a user testing a schedule at
- * 04:30 should not have the 05:00 occurrence skipped or the schedule shifted.
- * We therefore snapshot both timestamps before firing and restore them after,
- * leaving the persisted schedule untouched.
- */
-export async function runIoScheduleNow(id) {
-    const all = listIoSchedules();
-    const s = all.find((x) => x.id === id);
-    if (!s)
-        return false;
-    const previousLast = s.last_run_at;
-    const previousNext = s.next_run_at;
-    try {
-        await fireSchedule(s);
-    }
-    finally {
-        // Restore the original timestamps even if fireSchedule threw, so a
-        // failed manual run cannot silently shift the schedule either.
-        setIoScheduleTimestamps(id, previousLast, previousNext);
+    if (ioSchedulerInterval) {
+        clearInterval(ioSchedulerInterval);
+        ioSchedulerInterval = undefined;
     }
-    return true;
 }
 //# sourceMappingURL=io-scheduler.js.map

package/dist/copilot/model-router.js

@@ -1,84 +1,112 @@
-import { config } from "../config.js";
-const DEFAULT_TIERS = {
-    high: ["claude-opus-4.7", "claude-opus-4.6"],
-    medium: ["claude-sonnet-4.6", "gpt-5.5", "claude-opus-4.5"],
-    low: ["claude-haiku-4.5", "gpt-5.4-mini"],
+import { loadConfig } from "../config.js";
+import { getClient } from "./client.js";
+// Cache discovered models so we don't call listModels() on every task
+let discoveredModels;
+/**
+ * Built-in model capability hints. Used as fallback when billing info
+ * isn't available from the SDK. Higher = more capable.
+ */
+const MODEL_CAPABILITY_HINTS = {
+    "claude-opus-4.7": 90,
+    "claude-opus-4.6": 88,
+    "claude-opus-4.5": 85,
+    "gpt-5.5": 87,
+    "gpt-5.4": 84,
+    "gpt-5.3-codex": 83,
+    "gpt-5.2-codex": 82,
+    "gpt-5.2": 80,
+    "claude-sonnet-4.6": 70,
+    "claude-sonnet-4.5": 68,
+    "gpt-4.1": 65,
+    "claude-haiku-4.5": 40,
+    "gpt-5.4-mini": 42,
+    "gpt-5-mini": 38,
 };
-// Resolved model for each tier (populated at startup)
-let resolvedTiers = null;
-const HIGH_KEYWORDS = [
-    "architect", "refactor", "redesign", "debug", "design",
-    "complex", "migration", "security", "performance", "optimize",
-    "rewrite", "overhaul", "investigate", "diagnose", "plan",
-];
-const LOW_KEYWORDS = [
-    "read", "list", "format", "lookup", "check", "status",
-    "simple", "rename", "typo", "log", "print", "echo",
-    "delete file", "remove file", "copy file", "move file",
-];
 /**
- * Resolve each tier to the first available model from its preference list.
- * Call once at startup with the result of `client.listModels()`.
+ * Discover available models from the Copilot SDK and score them.
+ * Uses billing multiplier as primary capability signal, falls back to
+ * built-in hints for unknown models.
  */
-export function resolveModelTiers(availableModelIds) {
-    const available = new Set(availableModelIds);
-    const tiers = config.modelTiers ?? {};
-    const result = {};
-    for (const tier of ["high", "medium", "low"]) {
-        const candidates = tiers[tier] ?? DEFAULT_TIERS[tier];
-        const match = candidates.find((m) => available.has(m));
-        if (match) {
-            result[tier] = match;
-        }
-        else {
-            // Fallback: use defaultModel, then first candidate regardless of availability
-            result[tier] = config.defaultModel || candidates[0];
-        }
-        console.error(`[io] Model tier "${tier}" resolved to: ${result[tier]}`);
+export async function discoverModels() {
+    if (discoveredModels)
+        return discoveredModels;
+    try {
+        const client = await getClient();
+        const models = await client.listModels();
+        discoveredModels = models
+            .filter((m) => !m.policy || m.policy.state === "enabled")
+            .map((m) => ({
+            id: m.id,
+            // Use billing multiplier as capability proxy (higher cost = more capable)
+            // Fall back to built-in hints, then default of 50
+            score: m.billing
+                ? Math.min(m.billing.multiplier * 10, 100)
+                : (MODEL_CAPABILITY_HINTS[m.id] ?? 50),
+        }))
+            .sort((a, b) => b.score - a.score);
     }
-    resolvedTiers = result;
-    return result;
+    catch {
+        // SDK discovery failed — fall back to defaultModel only
+        const config = loadConfig();
+        discoveredModels = [{ id: config.defaultModel, score: 65 }];
+    }
+    return discoveredModels;
 }
-/**
- * Classify a task description into a complexity tier.
- */
-export function classifyComplexity(taskDescription) {
-    const lower = taskDescription.toLowerCase();
-    const highScore = HIGH_KEYWORDS.filter((kw) => lower.includes(kw)).length;
-    const lowScore = LOW_KEYWORDS.filter((kw) => lower.includes(kw)).length;
-    // Strong signals
-    if (highScore >= 2)
-        return "high";
-    if (lowScore >= 2)
-        return "low";
-    // Weak signals
-    if (highScore > lowScore)
-        return "high";
-    if (lowScore > highScore)
-        return "low";
-    // Default to medium for ambiguous tasks
-    return "medium";
+/** Reset cached models (e.g. after client reconnect) */
+export function resetModelCache() {
+    discoveredModels = undefined;
 }
 /**
- * Get the resolved model for a tier.
+ * Select the best available model for a given task complexity.
+ * Discovers models from the Copilot SDK and picks based on capability —
+ * zero configuration required.
  */
-export function getModelForTier(tier) {
-    if (!resolvedTiers) {
-        console.error("[io] Warning: model tiers not yet resolved, using defaults");
-        return config.defaultModel || DEFAULT_TIERS[tier][0];
+export async function selectModel(complexity) {
+    const config = loadConfig();
+    const scored = await discoverModels();
+    if (scored.length === 0)
+        return config.defaultModel;
+    if (complexity === "high") {
+        // Most capable model
+        return scored[0].id;
     }
-    return resolvedTiers[tier];
+    if (complexity === "low") {
+        // Cheapest model
+        return scored[scored.length - 1].id;
+    }
+    // Medium — pick a model around the middle of the ranked list
+    const midIdx = Math.floor(scored.length / 2);
+    return scored[midIdx].id;
 }
-/**
- * Get the best model for a task based on its description.
- * If squadModel is provided, it always takes priority.
- */
-export function getModelForTask(taskDescription, squadModel) {
-    if (squadModel)
-        return squadModel;
-    const tier = classifyComplexity(taskDescription);
-    const model = getModelForTier(tier);
-    console.error(`[io] Task classified as "${tier}" → model: ${model}`);
-    return model;
+export function classifyComplexity(task) {
+    const lower = task.toLowerCase();
+    const highPatterns = [
+        "architect",
+        "design system",
+        "refactor",
+        "security audit",
+        "performance optimization",
+        "migration",
+        "complex",
+        "deep analysis",
+        "debug",
+        "race condition",
+    ];
+    if (highPatterns.some((p) => lower.includes(p)))
+        return "high";
+    const lowPatterns = [
+        "format",
+        "rename",
+        "typo",
+        "simple",
+        "lookup",
+        "list",
+        "read",
+        "status",
+        "check",
+    ];
+    if (lowPatterns.some((p) => lower.includes(p)))
+        return "low";
+    return "medium";
 }
 //# sourceMappingURL=model-router.js.map