heyio 0.1.16 → 0.1.18

package/dist/copilot/agents.js

@@ -5,6 +5,7 @@ import { join, dirname, resolve } from "path";
 import { defineTool, approveAll } from "@github/copilot-sdk";
 import { z } from "zod";
 import { getClient } from "./client.js";
+import { getModelForTask } from "./model-router.js";
 import { getSquad, updateSquadSession, updateSquadStatus, getDecisionsSummary, logDecision, } from "../store/squads.js";
 import { createTask, completeTask, failTask, getActiveTasks, } from "../store/tasks.js";
 import { SESSIONS_DIR } from "../paths.js";
@@ -40,7 +41,7 @@ export async function delegateToAgent(squadSlug, task, onComplete) {
     if (!squad) {
         throw new Error(`Squad not found: ${squadSlug}`);
     }
-    const session = await getOrCreateSession(squadSlug);
+    const session = await getOrCreateSession(squadSlug, task);
     const taskId = randomUUID();
     createTask(taskId, squadSlug, task);
     updateSquadStatus(squadSlug, "working");
@@ -83,7 +84,7 @@ export function getActiveAgentTasks() {
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
-async function getOrCreateSession(squadSlug) {
+async function getOrCreateSession(squadSlug, taskDescription) {
     const existing = agentSessions.get(squadSlug);
     if (existing)
         return existing;
@@ -91,8 +92,9 @@ async function getOrCreateSession(squadSlug) {
     const client = await getClient();
     const decisions = getDecisionsSummary(squadSlug);
     const agentTools = buildAgentTools(squadSlug);
+    const model = getModelForTask(taskDescription ?? "", squad.model);
     const commonConfig = {
-        model: "gpt-4.1",
+        model,
         configDir: SESSIONS_DIR,
         streaming: false,
         systemMessage: {

package/dist/copilot/model-router.js

@@ -0,0 +1,84 @@
+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"],
+};
+// 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()`.
+ */
+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]}`);
+    }
+    resolvedTiers = result;
+    return result;
+}
+/**
+ * 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";
+}
+/**
+ * Get the resolved model for a tier.
+ */
+export function getModelForTier(tier) {
+    if (!resolvedTiers) {
+        console.error("[io] Warning: model tiers not yet resolved, using defaults");
+        return config.defaultModel || DEFAULT_TIERS[tier][0];
+    }
+    return resolvedTiers[tier];
+}
+/**
+ * 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;
+}
+//# sourceMappingURL=model-router.js.map

package/dist/copilot/orchestrator.js

@@ -5,6 +5,7 @@ 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 { resolveModelTiers } from "./model-router.js";
 import { searchWiki, getWikiSummary } from "../wiki/search.js";
 import { getOrchestratorSystemMessage } from "./system-message.js";
 import { createTools } from "./tools.js";
@@ -293,7 +294,7 @@ async function processQueue() {
 export async function initOrchestrator(copilotClient) {
     client = copilotClient;
     clearStaleTasks();
-    // Validate the configured model
+    // Validate the configured model and resolve model tiers
     try {
         const models = await copilotClient.listModels();
         const defaultModel = config.defaultModel || "gpt-4.1";
@@ -304,6 +305,7 @@ export async function initOrchestrator(copilotClient) {
         else {
             console.error(`[io] Model validated: ${defaultModel}`);
         }
+        resolveModelTiers(modelIds);
     }
     catch (err) {
         console.error("[io] Could not validate models:", err instanceof Error ? err.message : err);

package/dist/copilot/system-message.js

@@ -62,6 +62,14 @@ Squads are persistent project teams. When a user works on a codebase:
 3. Recall squad context with \`squad_recall\` before doing project work.
 4. Check squad status with \`squad_status\`.
 
+### Model Selection
+Squad agents are automatically assigned a model based on task complexity:
+- **High complexity** (architecture, refactoring, debugging, design) → most capable model
+- **Medium complexity** (implementing features, writing tests, reviews) → balanced model
+- **Low complexity** (file reads, formatting, lookups) → fast/cheap model
+
+The model is selected automatically. Tell the user which model tier was chosen when delegating tasks.
+
 ## Tool Usage
 
 ### Knowledge Base
@@ -78,6 +86,7 @@ Squads are persistent project teams. When a user works on a codebase:
 ### System
 - \`shell\`: Run a shell command. You have full system access — you can create directories, install packages, clone repos, etc. **Always use this instead of the built-in \`bash\` tool.**
 - \`file_ops\`: Read, write, or list files anywhere on the filesystem. Can create directories automatically.
+- \`github\`: Manage GitHub issues and PRs — create, list, view, comment, close issues; create, list, view, comment on PRs.
 - \`web_fetch\`: (built-in) Fetch a URL and return content.
 
 ## Guidelines

package/dist/copilot/tools.js

@@ -409,7 +409,132 @@ export function createTools(deps) {
             }
         },
     });
-    return [wikiRead, wikiWrite, wikiSearch, squadCreate, squadRecall, squadStatus, squadLogDecision, shell, fileOps, bash, readFile, viewTool, grepTool, strReplaceEditor];
+    // GitHub issue/PR management via gh CLI
+    const github = defineTool("github", {
+        description: "Manage GitHub issues and pull requests using the gh CLI. Supports creating, listing, viewing, and commenting on issues and PRs.",
+        skipPermission: true,
+        parameters: z.object({
+            action: z
+                .enum([
+                "create_issue",
+                "list_issues",
+                "view_issue",
+                "comment_issue",
+                "close_issue",
+                "create_pr",
+                "list_prs",
+                "view_pr",
+                "comment_pr",
+            ])
+                .describe("The GitHub action to perform"),
+            repo: z.string().describe("Repository in owner/repo format"),
+            title: z.string().optional().describe("Title (for create_issue, create_pr)"),
+            body: z.string().optional().describe("Body text (for create_issue, create_pr, comment_*)"),
+            labels: z.array(z.string()).optional().describe("Labels (for create_issue)"),
+            assignees: z.array(z.string()).optional().describe("Assignees (for create_issue)"),
+            number: z.number().optional().describe("Issue or PR number (for view, comment, close)"),
+            base: z.string().optional().describe("Base branch (for create_pr)"),
+            head: z.string().optional().describe("Head branch (for create_pr)"),
+            state: z.enum(["open", "closed", "all"]).optional().describe("Filter by state (for list_*)"),
+            limit: z.number().optional().describe("Max results (for list_*, default 10)"),
+        }),
+        handler: async ({ action, repo, title, body, labels, assignees, number, base, head, state, limit }) => {
+            console.error(`[io] github tool called: ${action} on ${repo}`);
+            try {
+                let cmd;
+                const r = `--repo ${repo}`;
+                switch (action) {
+                    case "create_issue": {
+                        if (!title)
+                            return "Error: title is required for create_issue";
+                        cmd = `gh issue create ${r} --title "${title.replace(/"/g, '\\"')}"`;
+                        if (body)
+                            cmd += ` --body "${body.replace(/"/g, '\\"')}"`;
+                        if (labels?.length)
+                            cmd += ` --label "${labels.join(",")}"`;
+                        if (assignees?.length)
+                            cmd += ` --assignee "${assignees.join(",")}"`;
+                        break;
+                    }
+                    case "list_issues": {
+                        cmd = `gh issue list ${r} --limit ${limit ?? 10}`;
+                        if (state)
+                            cmd += ` --state ${state}`;
+                        break;
+                    }
+                    case "view_issue": {
+                        if (!number)
+                            return "Error: number is required for view_issue";
+                        cmd = `gh issue view ${number} ${r}`;
+                        break;
+                    }
+                    case "comment_issue": {
+                        if (!number)
+                            return "Error: number is required for comment_issue";
+                        if (!body)
+                            return "Error: body is required for comment_issue";
+                        cmd = `gh issue comment ${number} ${r} --body "${body.replace(/"/g, '\\"')}"`;
+                        break;
+                    }
+                    case "close_issue": {
+                        if (!number)
+                            return "Error: number is required for close_issue";
+                        cmd = `gh issue close ${number} ${r}`;
+                        break;
+                    }
+                    case "create_pr": {
+                        if (!title)
+                            return "Error: title is required for create_pr";
+                        cmd = `gh pr create ${r} --title "${title.replace(/"/g, '\\"')}"`;
+                        if (body)
+                            cmd += ` --body "${body.replace(/"/g, '\\"')}"`;
+                        if (base)
+                            cmd += ` --base ${base}`;
+                        if (head)
+                            cmd += ` --head ${head}`;
+                        break;
+                    }
+                    case "list_prs": {
+                        cmd = `gh pr list ${r} --limit ${limit ?? 10}`;
+                        if (state)
+                            cmd += ` --state ${state}`;
+                        break;
+                    }
+                    case "view_pr": {
+                        if (!number)
+                            return "Error: number is required for view_pr";
+                        cmd = `gh pr view ${number} ${r}`;
+                        break;
+                    }
+                    case "comment_pr": {
+                        if (!number)
+                            return "Error: number is required for comment_pr";
+                        if (!body)
+                            return "Error: body is required for comment_pr";
+                        cmd = `gh pr comment ${number} ${r} --body "${body.replace(/"/g, '\\"')}"`;
+                        break;
+                    }
+                    default:
+                        return `Unknown action: ${action}`;
+                }
+                const result = execSync(cmd, {
+                    encoding: "utf-8",
+                    timeout: 30_000,
+                    maxBuffer: 1024 * 1024,
+                }).trim();
+                if (result.length > 8000) {
+                    return result.slice(0, 8000) + "\n\n[…truncated]";
+                }
+                return result || "(success, no output)";
+            }
+            catch (err) {
+                const execErr = err;
+                const msg = execErr.stderr?.trim() || execErr.stdout?.trim() || execErr.message || "Command failed";
+                return `Error: ${msg.length > 4000 ? msg.slice(0, 4000) + "\n[…truncated]" : msg}`;
+            }
+        },
+    });
+    return [wikiRead, wikiWrite, wikiSearch, squadCreate, squadRecall, squadStatus, squadLogDecision, shell, fileOps, bash, readFile, viewTool, grepTool, strReplaceEditor, github];
 }
 function walkDirectory(dir, maxDepth = 3, depth = 0) {
     if (depth >= maxDepth)

package/dist/store/db.js

@@ -21,6 +21,7 @@ export function getDb() {
       name TEXT NOT NULL,
       project_path TEXT NOT NULL,
       copilot_session_id TEXT,
+      model TEXT,
       status TEXT NOT NULL DEFAULT 'idle',
       created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
       updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
@@ -53,6 +54,13 @@ export function getDb() {
       completed_at DATETIME
     );
   `);
+    // Migration: add model column to squads (for existing databases)
+    try {
+        db.exec(`ALTER TABLE squads ADD COLUMN model TEXT`);
+    }
+    catch {
+        // Column already exists — ignore
+    }
     return db;
 }
 export function closeDb() {

package/dist/store/squads.js

@@ -22,6 +22,11 @@ export function updateSquadStatus(slug, status) {
         .prepare("UPDATE squads SET status = ?, updated_at = CURRENT_TIMESTAMP WHERE slug = ?")
         .run(status, slug);
 }
+export function updateSquadModel(slug, model) {
+    getDb()
+        .prepare("UPDATE squads SET model = ?, updated_at = CURRENT_TIMESTAMP WHERE slug = ?")
+        .run(model, slug);
+}
 export function deleteSquad(slug) {
     const db = getDb();
     db.prepare("DELETE FROM squad_decisions WHERE squad_slug = ?").run(slug);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heyio",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "IO — a personal AI assistant built on the GitHub Copilot SDK",
   "bin": {
     "io": "dist/index.js"