heyio 0.42.0 → 1.0.0

package/dist/store/squads.js

@@ -1,201 +1,50 @@
+import { randomUUID } from "node:crypto";
 import { getDb } from "./db.js";
-import { nextCharacter, randomUniverse, getOrCreateUniverse } from "../copilot/universes.js";
-// ---------------------------------------------------------------------------
-// Squad color palette — universe-inspired distinct colors
-// ---------------------------------------------------------------------------
-export const SQUAD_COLOR_PALETTE = [
-    "#ff6b35", // A-Team orange
-    "#ffd000", // Thundercats gold
-    "#5fff87", // GI Joe green
-    "#c4a7ff", // Ghostbusters purple
-    "#00d9ff", // Transformers cyan
-    "#ff9800", // extra amber
-    "#9c27b0", // extra violet
-    "#2196f3", // extra blue
-    "#e91e63", // extra pink
-    "#00bcd4", // extra teal
-    "#8bc34a", // extra lime
-    "#ff5722", // extra deep-orange
-];
-/**
- * Pick a color for a new squad. Prefers an unused palette color; when all
- * are taken, cycles through the palette by position (modular assignment).
- * This guarantees we never throw and always return a valid hex color.
- */
-export function pickSquadColor(existingColors) {
-    const used = new Set(existingColors.filter(Boolean));
-    const unused = SQUAD_COLOR_PALETTE.filter((c) => !used.has(c));
-    if (unused.length > 0)
-        return unused[0];
-    // All palette colors taken — cycle by squad count
-    return SQUAD_COLOR_PALETTE[used.size % SQUAD_COLOR_PALETTE.length];
-}
-export function createSquad(slug, name, projectPath, universeId) {
+export function createSquad(name, universe, repoUrl) {
     const db = getDb();
-    const universe = universeId
-        ? getOrCreateUniverse(universeId).id
-        : randomUniverse().id;
-    const existingSquads = listSquads();
-    const color = pickSquadColor(existingSquads.map((s) => s.color));
-    db.prepare("INSERT INTO squads (slug, name, project_path, universe, color) VALUES (?, ?, ?, ?, ?)").run(slug, name, projectPath, universe, color);
-    return getSquad(slug);
+    const id = randomUUID();
+    db.prepare("INSERT INTO squads (id, name, universe, repo_url) VALUES (?, ?, ?, ?)").run(id, name, universe, repoUrl ?? null);
+    return db.prepare("SELECT * FROM squads WHERE id = ?").get(id);
 }
-export function getSquad(slug) {
-    return getDb()
-        .prepare("SELECT * FROM squads WHERE slug = ?")
-        .get(slug);
+export function getSquad(id) {
+    const db = getDb();
+    return db.prepare("SELECT * FROM squads WHERE id = ?").get(id);
 }
 export function listSquads() {
-    return getDb().prepare("SELECT * FROM squads ORDER BY created_at DESC").all();
-}
-export function updateSquadSession(slug, sessionId) {
-    getDb()
-        .prepare("UPDATE squads SET copilot_session_id = ?, updated_at = CURRENT_TIMESTAMP WHERE slug = ?")
-        .run(sessionId, slug);
-}
-export function updateSquadStatus(slug, status) {
-    getDb()
-        .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_agents WHERE squad_slug = ?").run(slug);
-    db.prepare("DELETE FROM squad_decisions WHERE squad_slug = ?").run(slug);
-    db.prepare("DELETE FROM squads WHERE slug = ?").run(slug);
-}
-// ---------------------------------------------------------------------------
-// Squad Agent CRUD
-// ---------------------------------------------------------------------------
-/**
- * Add a named agent to a squad. Automatically assigns the next character
- * from the squad's universe pool.
- */
-export function addSquadAgent(squadSlug, roleTitle, charter, modelTier = "medium") {
-    const squad = getSquad(squadSlug);
-    if (!squad)
-        throw new Error(`Squad not found: ${squadSlug}`);
-    const universeId = squad.universe ?? randomUniverse().id;
-    // If squad doesn't have a universe yet, set it
-    if (!squad.universe) {
-        getDb()
-            .prepare("UPDATE squads SET universe = ? WHERE slug = ?")
-            .run(universeId, squadSlug);
-    }
-    // Ensure universe is registered in runtime array (handles restart for custom universes)
-    getOrCreateUniverse(universeId);
-    const existingAgents = listSquadAgents(squadSlug);
-    const usedNames = existingAgents.map((a) => a.character_name);
-    const character = nextCharacter(universeId, usedNames);
-    if (!character) {
-        throw new Error(`All characters in the "${universeId}" universe are assigned. Remove an agent first.`);
-    }
-    getDb()
-        .prepare(`INSERT INTO squad_agents (squad_slug, character_name, role_title, charter, model_tier, personality)
-       VALUES (?, ?, ?, ?, ?, ?)`)
-        .run(squadSlug, character.name, roleTitle, charter, modelTier, character.personality);
-    return getSquadAgent(squadSlug, character.name);
-}
-export function getSquadAgent(squadSlug, characterName) {
-    return getDb()
-        .prepare("SELECT * FROM squad_agents WHERE squad_slug = ? AND character_name = ?")
-        .get(squadSlug, characterName);
-}
-export function listSquadAgents(squadSlug) {
-    return getDb()
-        .prepare("SELECT * FROM squad_agents WHERE squad_slug = ? ORDER BY id ASC")
-        .all(squadSlug);
-}
-export function removeSquadAgent(squadSlug, characterName) {
-    const result = getDb()
-        .prepare("DELETE FROM squad_agents WHERE squad_slug = ? AND character_name = ?")
-        .run(squadSlug, characterName);
-    return result.changes > 0;
+    const squads = db.prepare("SELECT * FROM squads ORDER BY created_at DESC").all();
+    const agents = db.prepare("SELECT * FROM agents ORDER BY created_at").all();
+    return { squads, agents };
 }
-export function updateAgentSession(squadSlug, characterName, sessionId) {
-    getDb()
-        .prepare("UPDATE squad_agents SET copilot_session_id = ? WHERE squad_slug = ? AND character_name = ?")
-        .run(sessionId, squadSlug, characterName);
-}
-export function updateAgentStatus(squadSlug, characterName, status) {
-    getDb()
-        .prepare("UPDATE squad_agents SET status = ? WHERE squad_slug = ? AND character_name = ?")
-        .run(status, squadSlug, characterName);
-}
-/**
- * Clear an agent's persisted copilot_session_id. Used during error recovery
- * so the next task creates a fresh session instead of trying to resume a
- * poisoned one.
- */
-export function clearAgentSession(squadSlug, characterName) {
-    getDb()
-        .prepare("UPDATE squad_agents SET copilot_session_id = NULL WHERE squad_slug = ? AND character_name = ?")
-        .run(squadSlug, characterName);
-}
-/**
- * Reset any agent left in a non-idle status from a previous daemon run.
- * The in-memory Copilot sessions don't survive a restart, so persisted
- * "working" or "error" rows can never be accurate after startup. Returns
- * the number of rows reset for logging.
- */
-export function reconcileAgentStatuses() {
-    const info = getDb()
-        .prepare("UPDATE squad_agents SET status = 'idle' WHERE status IN ('working', 'error')")
-        .run();
-    return info.changes;
-}
-/**
- * Mirror of reconcileAgentStatuses for squads themselves.
- */
-export function reconcileSquadStatuses() {
-    const info = getDb()
-        .prepare("UPDATE squads SET status = 'idle' WHERE status IN ('working', 'error')")
-        .run();
-    return info.changes;
-}
-export function logDecision(squadSlug, decision, context) {
-    getDb()
-        .prepare("INSERT INTO squad_decisions (squad_slug, decision, context) VALUES (?, ?, ?)")
-        .run(squadSlug, decision, context ?? null);
+export function deleteSquad(id) {
+    const db = getDb();
+    db.prepare("DELETE FROM squads WHERE id = ?").run(id);
 }
-export function getDecisions(squadSlug, limit = 20) {
-    return getDb()
-        .prepare("SELECT * FROM squad_decisions WHERE squad_slug = ? ORDER BY created_at DESC, id DESC LIMIT ?")
-        .all(squadSlug, limit);
+export function updateSquadRules(id, rules) {
+    const db = getDb();
+    db.prepare("UPDATE squads SET rules = ?, updated_at = datetime('now') WHERE id = ?").run(rules, id);
 }
-export function getDecisionsSummary(squadSlug) {
-    const decisions = getDecisions(squadSlug);
-    if (decisions.length === 0)
-        return "No decisions recorded.";
-    return decisions
-        .reverse()
-        .map((d) => {
-        const ctx = d.context ? ` (${d.context})` : "";
-        return `- [${d.created_at}] ${d.decision}${ctx}`;
-    })
-        .join("\n");
+export function addAgent(squadId, input) {
+    const db = getDb();
+    const id = randomUUID();
+    db.prepare(`INSERT INTO agents (id, squad_id, character_name, role_title, persona, is_lead, is_qa, is_test)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, squadId, input.character_name, input.role_title, input.persona, input.is_lead ? 1 : 0, input.is_qa ? 1 : 0, input.is_test ? 1 : 0);
+    return db.prepare("SELECT * FROM agents WHERE id = ?").get(id);
 }
-export function setSquadLead(squadSlug, characterName) {
+export function getAgentsForSquad(squadId) {
     const db = getDb();
-    const tx = db.transaction(() => {
-        db.prepare("UPDATE squad_agents SET is_lead = 0 WHERE squad_slug = ?").run(squadSlug);
-        db.prepare("UPDATE squad_agents SET is_lead = 1 WHERE squad_slug = ? AND character_name = ?").run(squadSlug, characterName);
-    });
-    tx();
+    return db
+        .prepare("SELECT * FROM agents WHERE squad_id = ? ORDER BY created_at")
+        .all(squadId);
 }
-export function getSquadLead(squadSlug) {
-    return getDb()
-        .prepare("SELECT * FROM squad_agents WHERE squad_slug = ? AND is_lead = 1 LIMIT 1")
-        .get(squadSlug);
+export function getLeadForSquad(squadId) {
+    const db = getDb();
+    return db
+        .prepare("SELECT * FROM agents WHERE squad_id = ? AND is_lead = 1 LIMIT 1")
+        .get(squadId);
 }
-export function setSquadQA(squadSlug, characterName, isQA) {
-    getDb()
-        .prepare("UPDATE squad_agents SET is_qa = ? WHERE squad_slug = ? AND character_name = ?")
-        .run(isQA ? 1 : 0, squadSlug, characterName);
+export function updateAgentStatus(agentId, status) {
+    const db = getDb();
+    db.prepare("UPDATE agents SET status = ? WHERE id = ?").run(status, agentId);
 }
 //# sourceMappingURL=squads.js.map

package/dist/store/tasks.js

@@ -1,178 +1,35 @@
+import { randomUUID } from "node:crypto";
 import { getDb } from "./db.js";
-export function createTask(taskId, agentSlug, description, originChannel, instanceId) {
+export function createTask(squadId, description, instanceId, agentId) {
     const db = getDb();
-    db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, origin_channel, instance_id) VALUES (?, ?, ?, ?, ?)").run(taskId, agentSlug, description, originChannel ?? null, instanceId ?? null);
-    return getTask(taskId);
+    const id = randomUUID();
+    db.prepare(`INSERT INTO tasks (id, squad_id, instance_id, agent_id, description, status)
+     VALUES (?, ?, ?, ?, ?, 'pending')`).run(id, squadId, instanceId ?? null, agentId ?? null, description);
+    return db.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
 }
-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();
-}
-export function cancelTask(taskId, reason = "Cancelled by user") {
-    getDb()
-        .prepare("UPDATE agent_tasks SET status = 'cancelled', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ? AND status = 'running'")
-        .run(reason, taskId);
-}
-export function listRecentTasks(limit = 50) {
-    return getDb()
-        .prepare("SELECT * FROM agent_tasks ORDER BY datetime(started_at) DESC, task_id DESC LIMIT ?")
-        .all(limit);
-}
-/**
- * Per-agent task count for the most recent `limit` tasks belonging to a
- * squad. Matches tasks routed to the squad itself (`agent_slug = squadSlug`)
- * AND tasks routed to a named agent on the squad (`agent_slug LIKE 'squadSlug:%'`).
- * Used by squad_status to surface fan-out imbalance.
- */
-export function getSquadWorkDistribution(squadSlug, limit = 20) {
-    const rows = getDb()
-        .prepare(`SELECT agent_slug FROM agent_tasks
-       WHERE agent_slug = ? OR agent_slug LIKE ?
-       ORDER BY datetime(started_at) DESC, task_id DESC
-       LIMIT ?`)
-        .all(squadSlug, `${squadSlug}:%`, limit);
-    const counts = new Map();
-    for (const row of rows) {
-        counts.set(row.agent_slug, (counts.get(row.agent_slug) ?? 0) + 1);
-    }
-    const perAgent = Array.from(counts.entries())
-        .map(([agent_slug, count]) => ({ agent_slug, count }))
-        .sort((a, b) => b.count - a.count);
-    return { total: rows.length, perAgent };
-}
-export function createReview(taskId, squadSlug, reviewerCharacter, approved, comments) {
+export function getTasksForSquad(squadId) {
     const db = getDb();
-    const info = db
-        .prepare("INSERT INTO squad_task_reviews (task_id, squad_slug, reviewer_character, approved, comments) VALUES (?, ?, ?, ?, ?)")
-        .run(taskId, squadSlug, reviewerCharacter, approved ? 1 : 0, comments ?? null);
     return db
-        .prepare("SELECT * FROM squad_task_reviews WHERE id = ?")
-        .get(info.lastInsertRowid);
+        .prepare("SELECT * FROM tasks WHERE squad_id = ? ORDER BY created_at DESC")
+        .all(squadId);
 }
-export function getTaskReviews(taskId) {
-    return getDb()
-        .prepare("SELECT * FROM squad_task_reviews WHERE task_id = ? ORDER BY created_at ASC, id ASC")
-        .all(taskId);
-}
-/**
- * Per-character delegation stats for a squad.
- *
- * Returns one row PER CHARACTER NAME passed in `characterNames`, plus an
- * extra row with character_name="" for any tasks routed to the bare squad
- * slug (legacy lead tasks). Always returns a row for every requested
- * character, even if they have never been delegated to (task_count: 0,
- * last_delegated_at: null).
- *
- * Reads from the agent_stats view. Filters with `agent_slug = ?`
- * (for the bare slug) and `agent_slug = ?` for each `<slug>:<char>`.
- */
-export function getAgentTaskStats(squadSlug, characterNames) {
-    // Build the full set of agent_slug values we care about
-    const bareSlug = squadSlug;
-    const namedSlugs = characterNames.map((c) => `${squadSlug}:${c}`);
-    const allSlugs = [bareSlug, ...namedSlugs];
-    const placeholders = allSlugs.map(() => "?").join(", ");
-    const rows = getDb()
-        .prepare(`SELECT agent_slug, task_count, last_delegated_at FROM agent_stats WHERE agent_slug IN (${placeholders})`)
-        .all(...allSlugs);
-    const bySlug = new Map();
-    for (const row of rows)
-        bySlug.set(row.agent_slug, row);
-    const results = [];
-    // Bare slug row (legacy lead tasks routed without a named agent)
-    const bareRow = bySlug.get(bareSlug);
-    results.push({
-        character_name: "",
-        agent_slug: bareSlug,
-        task_count: bareRow?.task_count ?? 0,
-        last_delegated_at: bareRow?.last_delegated_at ?? null,
-    });
-    // One row per requested character
-    for (const char of characterNames) {
-        const slug = `${squadSlug}:${char}`;
-        const row = bySlug.get(slug);
-        results.push({
-            character_name: char,
-            agent_slug: slug,
-            task_count: row?.task_count ?? 0,
-            last_delegated_at: row?.last_delegated_at ?? null,
-        });
+export function updateTaskStatus(taskId, status, result) {
+    const db = getDb();
+    if (result !== undefined) {
+        db.prepare("UPDATE tasks SET status = ?, result = ?, updated_at = datetime('now') WHERE id = ?").run(status, result, taskId);
     }
-    return results;
-}
-/**
- * Pick the stalest specialist in a squad. "Stalest" = the character who
- * has been delegated to least recently (oldest last_delegated_at), with
- * never-delegated agents considered staler than any delegated agent.
- *
- * Excludes character names listed in `excludeCharacters` (use this to
- * skip the lead). Returns null if the squad has no eligible agents OR if
- * all eligible agents have been delegated to within `freshIfWithinHours`
- * (default 48). The threshold is meant to suppress the hint when the
- * squad is already distributing well.
- *
- * On tie (e.g. two agents have never been delegated), returns the one
- * that sorts first by character_name (deterministic).
- */
-export function getStalestSpecialist(squadSlug, characterNames, options) {
-    const exclude = new Set(options?.excludeCharacters ?? []);
-    const freshThresholdHours = options?.freshIfWithinHours ?? 48;
-    const stats = getAgentTaskStats(squadSlug, characterNames);
-    // Filter: named agents only (skip the bare-slug "" row), skip excluded
-    const eligible = stats.filter((s) => s.character_name !== "" && !exclude.has(s.character_name));
-    if (eligible.length === 0)
-        return null;
-    const now = Date.now();
-    // Sort: never-delegated (null) first, then ascending by last_delegated_at
-    eligible.sort((a, b) => {
-        if (a.last_delegated_at === null && b.last_delegated_at === null) {
-            return a.character_name.localeCompare(b.character_name);
-        }
-        if (a.last_delegated_at === null)
-            return -1;
-        if (b.last_delegated_at === null)
-            return 1;
-        const tA = new Date(a.last_delegated_at + "Z").getTime();
-        const tB = new Date(b.last_delegated_at + "Z").getTime();
-        if (tA !== tB)
-            return tA - tB;
-        return a.character_name.localeCompare(b.character_name);
-    });
-    const stalest = eligible[0];
-    let staleHours = null;
-    if (stalest.last_delegated_at !== null) {
-        const delegatedAt = new Date(stalest.last_delegated_at + "Z").getTime();
-        staleHours = Math.round((now - delegatedAt) / 3_600_000);
-        // Squad is distributing well — suppress the hint
-        if (staleHours < freshThresholdHours)
-            return null;
+    else {
+        db.prepare("UPDATE tasks SET status = ?, updated_at = datetime('now') WHERE id = ?").run(status, taskId);
     }
-    // null last_delegated_at means never-delegated: always considered stale
-    return {
-        character_name: stalest.character_name,
-        last_delegated_at: stalest.last_delegated_at,
-        staleHours,
-    };
+}
+export function getTask(taskId) {
+    const db = getDb();
+    return db.prepare("SELECT * FROM tasks WHERE id = ?").get(taskId);
+}
+export function getActiveTasksForInstance(instanceId) {
+    const db = getDb();
+    return db
+        .prepare("SELECT * FROM tasks WHERE instance_id = ? AND status NOT IN ('done', 'failed') ORDER BY created_at")
+        .all(instanceId);
 }
 //# sourceMappingURL=tasks.js.map