heyio 0.40.0 → 0.41.0

package/dist/api/server.js

@@ -19,7 +19,7 @@ import { listSchedules, getSchedule, deleteSchedule, setScheduleEnabled } from "
 import { listIoSchedules, getIoSchedule, deleteIoSchedule, setIoScheduleEnabled } from "../store/io-schedules.js";
 import { getScheduleRuns } from "../store/schedule-runs.js";
 import { createFeedEntry, listFeedEntries, listFeedSquads, countUnreadFeedEntries, markFeedEntryRead, markAllFeedEntriesRead, deleteFeedEntry, markFeedEntriesRead, deleteFeedEntries } from "../store/feed.js";
-import { listPages, readPage } from "../wiki/fs.js";
+import { listPages, readPage, writePage, deletePage, assertPagePath } from "../wiki/fs.js";
 import { runScheduleNow } from "../copilot/scheduler.js";
 import { runIoScheduleNow } from "../copilot/io-scheduler.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -958,7 +958,7 @@ export async function startApiServer() {
     });
     api.get("/wiki/*path", (req, res) => {
         try {
-            const pagePath = Array.isArray(req.params.path) ? req.params.path[0] : req.params.path;
+            const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
             if (!pagePath) {
                 res.status(400).json({ error: "Missing page path" });
                 return;
@@ -975,6 +975,100 @@ export async function startApiServer() {
             res.status(500).json({ error: "Failed to read wiki page" });
         }
     });
+    // Create a new wiki page
+    api.post("/wiki", (req, res) => {
+        try {
+            const { path: pagePath, content } = req.body;
+            if (!pagePath || typeof pagePath !== "string") {
+                res.status(400).json({ error: "Missing page path" });
+                return;
+            }
+            if (content === undefined || typeof content !== "string") {
+                res.status(400).json({ error: "Missing page content" });
+                return;
+            }
+            try {
+                assertPagePath(pagePath);
+            }
+            catch (e) {
+                res.status(400).json({ error: e.message });
+                return;
+            }
+            if (readPage(pagePath) !== undefined) {
+                res.status(409).json({ error: "Page already exists" });
+                return;
+            }
+            writePage(pagePath, content);
+            res.status(201).json({ path: pagePath, content });
+        }
+        catch (e) {
+            console.error("Error creating wiki page:", e);
+            res.status(500).json({ error: "Failed to create wiki page" });
+        }
+    });
+    // Update an existing wiki page
+    api.put("/wiki/*path", (req, res) => {
+        try {
+            const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
+            if (!pagePath) {
+                res.status(400).json({ error: "Missing page path" });
+                return;
+            }
+            const { content } = req.body;
+            if (content === undefined || typeof content !== "string") {
+                res.status(400).json({ error: "Missing page content" });
+                return;
+            }
+            try {
+                assertPagePath(pagePath);
+            }
+            catch (e) {
+                res.status(400).json({ error: e.message });
+                return;
+            }
+            if (readPage(pagePath) === undefined) {
+                res.status(404).json({ error: "Page not found" });
+                return;
+            }
+            writePage(pagePath, content);
+            res.json({ path: pagePath, content });
+        }
+        catch (e) {
+            console.error("Error updating wiki page:", e);
+            res.status(500).json({ error: "Failed to update wiki page" });
+        }
+    });
+    // Delete a wiki page
+    api.delete("/wiki/*path", (req, res) => {
+        try {
+            const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
+            if (!pagePath) {
+                res.status(400).json({ error: "Missing page path" });
+                return;
+            }
+            try {
+                assertPagePath(pagePath);
+            }
+            catch (e) {
+                res.status(400).json({ error: e.message });
+                return;
+            }
+            const deleted = deletePage(pagePath);
+            if (!deleted) {
+                res.status(404).json({ error: "Page not found" });
+                return;
+            }
+            res.status(204).send();
+        }
+        catch (e) {
+            console.error("Error deleting wiki page:", e);
+            res.status(500).json({ error: "Failed to delete wiki page" });
+        }
+    });
+    // Get available wiki categories
+    api.get("/wiki-categories", (_req, res) => {
+        res.json({ categories: ["preferences", "projects", "people", "general", "squads"] });
+    });
     // Mount API at /api (for frontend)
     app.use("/api", api);
     // Serve Vue frontend if built assets exist (before backward-compat API mount)

package/dist/api/wiki.test.js

@@ -0,0 +1,283 @@
+/**
+ * Integration tests for Wiki API endpoints (#312).
+ * Tests POST, PUT, DELETE endpoints for wiki pages.
+ */
+import { describe, it, before, after, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import http from "node:http";
+import express from "express";
+import { listPages, readPage, writePage, deletePage, assertPagePath, ensureWikiStructure, } from "../wiki/fs.js";
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function req(method, port, path, body) {
+    return new Promise((resolve, reject) => {
+        const payload = body !== undefined ? JSON.stringify(body) : undefined;
+        const options = {
+            hostname: "127.0.0.1",
+            port,
+            path,
+            method,
+            headers: {
+                ...(payload ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) } : {}),
+            },
+        };
+        const r = http.request(options, (res) => {
+            let data = "";
+            res.on("data", (chunk) => { data += chunk; });
+            res.on("end", () => {
+                try {
+                    resolve({ status: res.statusCode ?? 0, body: data ? JSON.parse(data) : {} });
+                }
+                catch {
+                    resolve({ status: res.statusCode ?? 0, body: data });
+                }
+            });
+        });
+        r.on("error", reject);
+        if (payload)
+            r.write(payload);
+        r.end();
+    });
+}
+// ── Server Setup ──────────────────────────────────────────────────────────────
+function createTestServer() {
+    const app = express();
+    app.use(express.json());
+    // Wiki list
+    app.get("/api/wiki", (_req, res) => {
+        try {
+            const pages = listPages();
+            const result = pages.map((pagePath) => {
+                const pageContent = readPage(pagePath);
+                const title = pageContent?.match(/^#\s+(.+)/m)?.[1]?.trim() ?? pagePath;
+                return { path: pagePath, title };
+            });
+            res.json({ pages: result });
+        }
+        catch (e) {
+            res.status(500).json({ error: "Failed to list wiki pages" });
+        }
+    });
+    // Wiki read
+    app.get("/api/wiki/*path", (req, res) => {
+        const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
+        if (!pagePath) {
+            res.status(400).json({ error: "Missing page path" });
+            return;
+        }
+        const pageContent = readPage(pagePath);
+        if (pageContent === undefined) {
+            res.status(404).json({ error: "Page not found" });
+            return;
+        }
+        res.json({ path: pagePath, content: pageContent });
+    });
+    // Wiki create
+    app.post("/api/wiki", (req, res) => {
+        const { path: pagePath, content } = req.body;
+        if (!pagePath || typeof pagePath !== "string") {
+            res.status(400).json({ error: "Missing page path" });
+            return;
+        }
+        if (content === undefined || typeof content !== "string") {
+            res.status(400).json({ error: "Missing page content" });
+            return;
+        }
+        try {
+            assertPagePath(pagePath);
+        }
+        catch (e) {
+            res.status(400).json({ error: e.message });
+            return;
+        }
+        if (readPage(pagePath) !== undefined) {
+            res.status(409).json({ error: "Page already exists" });
+            return;
+        }
+        writePage(pagePath, content);
+        res.status(201).json({ path: pagePath, content });
+    });
+    // Wiki update
+    app.put("/api/wiki/*path", (req, res) => {
+        const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
+        if (!pagePath) {
+            res.status(400).json({ error: "Missing page path" });
+            return;
+        }
+        const { content } = req.body;
+        if (content === undefined || typeof content !== "string") {
+            res.status(400).json({ error: "Missing page content" });
+            return;
+        }
+        try {
+            assertPagePath(pagePath);
+        }
+        catch (e) {
+            res.status(400).json({ error: e.message });
+            return;
+        }
+        if (readPage(pagePath) === undefined) {
+            res.status(404).json({ error: "Page not found" });
+            return;
+        }
+        writePage(pagePath, content);
+        res.json({ path: pagePath, content });
+    });
+    // Wiki delete
+    app.delete("/api/wiki/*path", (req, res) => {
+        const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
+        if (!pagePath) {
+            res.status(400).json({ error: "Missing page path" });
+            return;
+        }
+        try {
+            assertPagePath(pagePath);
+        }
+        catch (e) {
+            res.status(400).json({ error: e.message });
+            return;
+        }
+        const deleted = deletePage(pagePath);
+        if (!deleted) {
+            res.status(404).json({ error: "Page not found" });
+            return;
+        }
+        res.status(204).send();
+    });
+    // Wiki categories
+    app.get("/api/wiki-categories", (_req, res) => {
+        res.json({ categories: ["preferences", "projects", "people", "general", "squads"] });
+    });
+    return app;
+}
+// ── Tests ─────────────────────────────────────────────────────────────────────
+describe("Wiki API Endpoints", () => {
+    let server;
+    let port;
+    const testPagePath = `pages/general/test-wiki-api-${Date.now()}.md`;
+    before(() => {
+        ensureWikiStructure();
+        const app = createTestServer();
+        server = app.listen(0);
+        port = server.address().port;
+    });
+    after(() => {
+        server.close();
+        // Clean up test page if exists
+        try {
+            deletePage(testPagePath);
+        }
+        catch { /* ignore */ }
+    });
+    afterEach(() => {
+        // Clean up test page after each test
+        try {
+            deletePage(testPagePath);
+        }
+        catch { /* ignore */ }
+    });
+    describe("GET /api/wiki", () => {
+        it("returns list of wiki pages", async () => {
+            const { status, body } = await req("GET", port, "/api/wiki");
+            assert.equal(status, 200);
+            assert.ok(Array.isArray(body.pages));
+        });
+    });
+    describe("GET /api/wiki-categories", () => {
+        it("returns available categories", async () => {
+            const { status, body } = await req("GET", port, "/api/wiki-categories");
+            assert.equal(status, 200);
+            const categories = body.categories;
+            assert.ok(categories.includes("general"));
+            assert.ok(categories.includes("projects"));
+            assert.ok(categories.includes("preferences"));
+        });
+    });
+    describe("POST /api/wiki", () => {
+        it("creates a new wiki page", async () => {
+            const { status, body } = await req("POST", port, "/api/wiki", {
+                path: testPagePath,
+                content: "# Test Page\n\nThis is a test.",
+            });
+            assert.equal(status, 201);
+            assert.equal(body.path, testPagePath);
+            // Verify it was created
+            const page = readPage(testPagePath);
+            assert.ok(page?.includes("# Test Page"));
+        });
+        it("returns 409 if page already exists", async () => {
+            writePage(testPagePath, "# Existing");
+            const { status, body } = await req("POST", port, "/api/wiki", {
+                path: testPagePath,
+                content: "# New Content",
+            });
+            assert.equal(status, 409);
+            assert.equal(body.error, "Page already exists");
+        });
+        it("returns 400 for missing path", async () => {
+            const { status } = await req("POST", port, "/api/wiki", {
+                content: "# Test",
+            });
+            assert.equal(status, 400);
+        });
+        it("returns 400 for missing content", async () => {
+            const { status } = await req("POST", port, "/api/wiki", {
+                path: testPagePath,
+            });
+            assert.equal(status, 400);
+        });
+        it("returns 400 for invalid path (not under pages/)", async () => {
+            const { status, body } = await req("POST", port, "/api/wiki", {
+                path: "invalid/path.md",
+                content: "# Test",
+            });
+            assert.equal(status, 400);
+            assert.ok(body.error.includes("pages/"));
+        });
+    });
+    describe("PUT /api/wiki/*path", () => {
+        it("updates an existing wiki page", async () => {
+            writePage(testPagePath, "# Original Content");
+            const { status, body } = await req("PUT", port, `/api/wiki/${testPagePath}`, {
+                content: "# Updated Content\n\nNew text here.",
+            });
+            assert.equal(status, 200);
+            assert.equal(body.path, testPagePath);
+            // Verify it was updated
+            const page = readPage(testPagePath);
+            assert.ok(page?.includes("Updated Content"));
+        });
+        it("returns 404 if page does not exist", async () => {
+            const { status, body } = await req("PUT", port, `/api/wiki/${testPagePath}`, {
+                content: "# New Content",
+            });
+            assert.equal(status, 404);
+            assert.equal(body.error, "Page not found");
+        });
+        it("returns 400 for missing content", async () => {
+            writePage(testPagePath, "# Original");
+            const { status } = await req("PUT", port, `/api/wiki/${testPagePath}`, {});
+            assert.equal(status, 400);
+        });
+    });
+    describe("DELETE /api/wiki/*path", () => {
+        it("deletes an existing wiki page", async () => {
+            writePage(testPagePath, "# To Delete");
+            const { status } = await req("DELETE", port, `/api/wiki/${testPagePath}`);
+            assert.equal(status, 204);
+            // Verify it was deleted
+            const page = readPage(testPagePath);
+            assert.equal(page, undefined);
+        });
+        it("returns 404 if page does not exist", async () => {
+            const { status, body } = await req("DELETE", port, `/api/wiki/${testPagePath}`);
+            assert.equal(status, 404);
+            assert.equal(body.error, "Page not found");
+        });
+        it("returns 400 for invalid path", async () => {
+            const { status, body } = await req("DELETE", port, "/api/wiki/invalid-path.md");
+            assert.equal(status, 400);
+            assert.ok(body.error.includes("pages/"));
+        });
+    });
+});
+//# sourceMappingURL=wiki.test.js.map

package/dist/copilot/skills.js

@@ -310,4 +310,76 @@ export async function searchSkillsRegistry(query) {
         return [];
     }
 }
+/**
+ * Update a skill's metadata (name and/or description).
+ * Rewrites the SKILL.md file with the updated frontmatter while preserving content.
+ * Throws if the skill doesn't exist.
+ */
+export function updateSkill(slug, updates) {
+    const skillDir = join(SKILLS_DIR, slug);
+    if (!existsSync(skillDir)) {
+        throw new Error(`Skill not found: ${slug}`);
+    }
+    const skillMdPath = join(skillDir, "SKILL.md");
+    if (!existsSync(skillMdPath)) {
+        throw new Error(`SKILL.md not found for skill: ${slug}`);
+    }
+    const currentContent = readFileSync(skillMdPath, "utf-8");
+    const { name: currentName, description: currentDescription } = parseSkillMd(currentContent);
+    // Use provided updates or fall back to current values
+    const newName = updates.name ?? currentName;
+    const newDescription = updates.description ?? currentDescription;
+    // Rebuild SKILL.md with new metadata
+    // Keep everything after the description intact (preserve any extra content)
+    const lines = currentContent.split(/\r?\n/);
+    const newLines = [];
+    // Add the new heading
+    newLines.push(`# ${newName}`);
+    newLines.push("");
+    // Add the new description
+    if (newDescription) {
+        newLines.push(newDescription);
+        newLines.push("");
+    }
+    // Find where the original description ends and append the rest
+    let foundHeading = false;
+    let skippedDescription = false;
+    let blankLinesSeen = 0;
+    for (const line of lines) {
+        if (!foundHeading) {
+            if (line.match(/^#\s+(.+)/)) {
+                foundHeading = true;
+            }
+            continue;
+        }
+        if (!skippedDescription) {
+            if (line.trim() === "") {
+                blankLinesSeen++;
+                if (blankLinesSeen >= 2) {
+                    skippedDescription = true;
+                }
+            }
+            else {
+                blankLinesSeen = 0;
+            }
+            continue;
+        }
+        // We're past the description now
+        newLines.push(line);
+    }
+    const newContent = newLines.join("\n");
+    writeFileSync(skillMdPath, newContent, "utf-8");
+    return {
+        name: newName,
+        slug,
+        description: newDescription,
+        path: skillDir,
+    };
+}
+/**
+ * Delete a skill (alias for removeSkill for consistency with other store modules).
+ */
+export function deleteSkill(slug) {
+    return removeSkill(slug);
+}
 //# sourceMappingURL=skills.js.map

package/dist/copilot/skills.test.js

@@ -0,0 +1,55 @@
+/**
+ * Tests for src/copilot/skills.ts — skill installation, listing, and management.
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { parseSkillUrl, removeSkill, updateSkill, deleteSkill, } from "./skills.js";
+// ── Tests ─────────────────────────────────────────────────────────────────────
+describe("parseSkillUrl", () => {
+    it("parses GitHub blob URLs for SKILL.md", () => {
+        const url = "https://github.com/owner/repo/blob/main/SKILL.md";
+        const result = parseSkillUrl(url);
+        assert.equal(result.type, "file");
+        assert.ok("rawUrl" in result);
+        assert.ok(result.rawUrl.includes("raw.githubusercontent.com"));
+    });
+    it("parses GitHub raw content URLs", () => {
+        const url = "https://raw.githubusercontent.com/owner/repo/main/SKILL.md";
+        const result = parseSkillUrl(url);
+        assert.equal(result.type, "file");
+        assert.ok("rawUrl" in result);
+    });
+    it("parses GitHub repo URLs as repo type", () => {
+        const url = "https://github.com/owner/repo";
+        const result = parseSkillUrl(url);
+        assert.equal(result.type, "repo");
+        assert.equal(result.url, url);
+    });
+    it("rejects non-https SKILL.md URLs", () => {
+        const url = "http://example.com/SKILL.md";
+        assert.throws(() => parseSkillUrl(url));
+    });
+    it("derives slug from repo name with path prefix", () => {
+        const url = "https://github.com/owner/repo/blob/main/skills/ai-chat/SKILL.md";
+        const result = parseSkillUrl(url);
+        assert.equal(result.type, "file");
+        assert.ok(result.slug.includes("repo"));
+    });
+});
+describe("skill store functions", () => {
+    it("exports updateSkill function", () => {
+        assert.ok(typeof updateSkill === "function");
+    });
+    it("exports deleteSkill function", () => {
+        assert.ok(typeof deleteSkill === "function");
+    });
+    it("exports removeSkill function", () => {
+        assert.ok(typeof removeSkill === "function");
+    });
+    it("deleteSkill is callable (alias)", () => {
+        // Just verify these are functions and importable
+        assert.ok(deleteSkill !== undefined);
+        assert.ok(removeSkill !== undefined);
+    });
+});
+//# sourceMappingURL=skills.test.js.map

package/dist/store/db.js

@@ -172,6 +172,7 @@ GROUP BY agent_slug`,
     )`,
         `CREATE INDEX IF NOT EXISTS idx_unified_feed_type ON unified_feed(type, created_at)`,
         `CREATE INDEX IF NOT EXISTS idx_unified_feed_unread ON unified_feed(read_at, created_at)`,
+        `ALTER TABLE squads ADD COLUMN color TEXT`,
         `CREATE TABLE IF NOT EXISTS squad_instances (
       id TEXT PRIMARY KEY,
       master_squad_slug TEXT NOT NULL,
@@ -213,6 +214,7 @@ GROUP BY agent_slug`,
         `DROP TABLE unified_feed_old`,
         `CREATE INDEX IF NOT EXISTS idx_unified_feed_type ON unified_feed(type, created_at)`,
         `CREATE INDEX IF NOT EXISTS idx_unified_feed_unread ON unified_feed(read_at, created_at)`,
+        `ALTER TABLE squads ADD COLUMN color TEXT`,
     ];
     for (const migration of migrations) {
         try {
@@ -242,6 +244,32 @@ GROUP BY agent_slug`,
     catch {
         // Migration failed (e.g. old tables don't exist yet on a fresh install) — safe to ignore
     }
+    // One-time migration: assign colors to existing squads that have none
+    try {
+        const colorMigrated = db.prepare("SELECT value FROM io_state WHERE key = 'squad_colors_migrated'").get();
+        if (!colorMigrated) {
+            const palette = [
+                "#ff6b35", "#ffd000", "#5fff87", "#c4a7ff", "#00d9ff",
+                "#ff9800", "#9c27b0", "#2196f3", "#e91e63", "#00bcd4",
+                "#8bc34a", "#ff5722",
+            ];
+            const uncolored = db.prepare("SELECT slug FROM squads WHERE color IS NULL ORDER BY id ASC").all();
+            const usedColors = new Set(db.prepare("SELECT color FROM squads WHERE color IS NOT NULL").all().map(r => r.color));
+            const update = db.prepare("UPDATE squads SET color = ? WHERE slug = ?");
+            let idx = 0;
+            for (const { slug } of uncolored) {
+                const available = palette.filter(c => !usedColors.has(c));
+                const color = available.length > 0 ? available[0] : palette[idx % palette.length];
+                update.run(color, slug);
+                usedColors.add(color);
+                idx++;
+            }
+            db.prepare("INSERT OR REPLACE INTO io_state (key, value) VALUES ('squad_colors_migrated', '1')").run();
+        }
+    }
+    catch {
+        // Safe to ignore on fresh install
+    }
     return db;
 }
 export function closeDb() {

package/dist/store/squads.js

@@ -1,11 +1,43 @@
 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) {
     const db = getDb();
     const universe = universeId
         ? getOrCreateUniverse(universeId).id
         : randomUniverse().id;
-    db.prepare("INSERT INTO squads (slug, name, project_path, universe) VALUES (?, ?, ?, ?)").run(slug, name, projectPath, universe);
+    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);
 }
 export function getSquad(slug) {