verybot 0.1.3

package/dist/skills/read-tool.js

@@ -0,0 +1,24 @@
+import { tool } from "ai";
+import { z } from "zod";
+/**
+ * Create the read_skill tool with the given skill entries baked in.
+ * Returns the full SKILL.md content for the requested skill name.
+ */
+export function createReadSkillTool(skills) {
+    const skillMap = new Map(skills.map((s) => [s.name.toLowerCase(), s]));
+    const validNames = skills.map((s) => s.name).join(", ");
+    return tool({
+        description: `Read the full instructions for a skill. Available: ${validNames}. ` +
+            `Call this before applying a skill so you know its full instructions.`,
+        inputSchema: z.object({
+            name: z.string().describe("The skill name to read"),
+        }),
+        execute: async ({ name }) => {
+            const entry = skillMap.get(name.toLowerCase());
+            if (!entry) {
+                return `Unknown skill "${name}". Available: ${validNames}`;
+            }
+            return entry.content;
+        },
+    });
+}

package/dist/skills/scanner.d.ts

@@ -0,0 +1,6 @@
+import type { SkillEntry } from "./types.js";
+/**
+ * Scan `dir` for subdirectories containing SKILL.md files.
+ * Returns metadata for each discovered skill.
+ */
+export declare function scanSkills(dir: string): Promise<SkillEntry[]>;

package/dist/skills/scanner.js

@@ -0,0 +1,73 @@
+import { readdir, readFile, stat } from "fs/promises";
+import { join, basename, resolve } from "path";
+import { logger } from "../logger.js";
+const SKILL_FILENAME = "SKILL.md";
+/** Parse optional YAML frontmatter delimited by --- */
+function parseFrontmatter(raw) {
+    const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+    if (!match)
+        return { meta: {}, body: raw };
+    const meta = {};
+    for (const line of match[1].split("\n")) {
+        const colon = line.indexOf(":");
+        if (colon === -1)
+            continue;
+        const key = line.slice(0, colon).trim();
+        let value = line.slice(colon + 1).trim();
+        // Handle inline YAML list: tools: [a, b, c]
+        if (typeof value === "string" && value.startsWith("[") && value.endsWith("]")) {
+            value = value
+                .slice(1, -1)
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean);
+        }
+        meta[key] = value;
+    }
+    return { meta, body: match[2] };
+}
+/**
+ * Scan `dir` for subdirectories containing SKILL.md files.
+ * Returns metadata for each discovered skill.
+ */
+export async function scanSkills(dir) {
+    const absDir = resolve(dir);
+    let entries;
+    try {
+        entries = await readdir(absDir);
+    }
+    catch {
+        logger.info(`Skills directory not found: ${absDir} (skipping)`);
+        return [];
+    }
+    const skills = [];
+    const seenNames = new Set();
+    for (const entry of entries) {
+        const entryPath = join(absDir, entry);
+        const entryStat = await stat(entryPath).catch(() => null);
+        if (!entryStat?.isDirectory())
+            continue;
+        const skillFile = join(entryPath, SKILL_FILENAME);
+        let raw;
+        try {
+            raw = await readFile(skillFile, "utf-8");
+        }
+        catch {
+            continue; // no SKILL.md in this directory
+        }
+        const { meta, body } = parseFrontmatter(raw);
+        const name = meta.name ?? basename(entryPath);
+        const description = meta.description ?? "";
+        const tools = Array.isArray(meta.tools) ? meta.tools : [];
+        const icon = meta.icon ?? undefined;
+        const normalizedName = name.toLowerCase();
+        if (seenNames.has(normalizedName)) {
+            logger.warn(`Duplicate skill name "${name}" at ${skillFile}, skipping`);
+            continue;
+        }
+        seenNames.add(normalizedName);
+        skills.push({ name, description, content: body, tools, icon, path: skillFile });
+        // logger.info(`Loaded skill: ${name}${description ? ` — ${description}` : ""}`);
+    }
+    return skills;
+}

package/dist/skills/types.d.ts

@@ -0,0 +1,15 @@
+/** Metadata parsed from a SKILL.md frontmatter during startup scan. */
+export interface SkillEntry {
+    /** Skill name (from frontmatter `name` or directory name) */
+    name: string;
+    /** One-line description (from frontmatter `description`) */
+    description: string;
+    /** Full raw content of SKILL.md (cached for read_skill tool) */
+    content: string;
+    /** Optional list of tool names this skill references */
+    tools: string[];
+    /** Optional Lucide icon name */
+    icon?: string;
+    /** Absolute path to the SKILL.md file */
+    path: string;
+}

package/dist/skills/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tasks/store.d.ts

@@ -0,0 +1,47 @@
+import type { Task, TaskStatus, TaskPriority } from "./types.js";
+export interface CreateTaskInput {
+    title: string;
+    description?: string;
+    teamId?: string;
+    assignee?: string;
+    priority?: TaskPriority;
+    status?: TaskStatus;
+}
+export interface UpdateTaskInput {
+    title?: string;
+    description?: string | null;
+    status?: TaskStatus;
+    assignee?: string | null;
+    priority?: TaskPriority;
+    teamId?: string | null;
+}
+export interface ListTasksFilter {
+    teamId?: string;
+    status?: TaskStatus;
+    assignee?: string;
+    includeArchived?: boolean;
+}
+/**
+ * SQLite-backed persistence for team tasks.
+ * Shares the same DB file as MemoryStore, ScheduleStore, etc.
+ */
+export declare class TaskStore {
+    private db;
+    private constructor();
+    static create(dbPath: string): Promise<TaskStore>;
+    private createSchema;
+    /** Add position column for existing databases that lack it. */
+    private migrate;
+    /** Get the next position value for a given status (appends to end). */
+    private nextPosition;
+    create(input: CreateTaskInput): Task;
+    update(id: string, input: UpdateTaskInput): Task | null;
+    /** Bulk-reorder tasks within a status column. Sets positions 0, 1, 2, ... */
+    reorder(status: TaskStatus, orderedIds: string[]): void;
+    delete(id: string): boolean;
+    getById(id: string): Task | null;
+    list(filter?: ListTasksFilter): Task[];
+    /** Bulk-archive all done tasks, optionally scoped to a team. */
+    archiveDone(teamId?: string): number;
+    close(): void;
+}

package/dist/tasks/store.js

@@ -0,0 +1,193 @@
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import { randomUUID } from "crypto";
+import Database from "better-sqlite3";
+import { logger } from "../logger.js";
+import { DEFAULT_TEAM_ID } from "../config/agent-config.js";
+/**
+ * SQLite-backed persistence for team tasks.
+ * Shares the same DB file as MemoryStore, ScheduleStore, etc.
+ */
+export class TaskStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    static async create(dbPath) {
+        mkdirSync(dirname(dbPath), { recursive: true });
+        const db = new Database(dbPath);
+        db.pragma("journal_mode = WAL");
+        const store = new TaskStore(db);
+        store.createSchema();
+        store.migrate();
+        return store;
+    }
+    createSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        team_id TEXT,
+        title TEXT NOT NULL,
+        description TEXT,
+        status TEXT NOT NULL DEFAULT 'todo',
+        assignee TEXT,
+        priority TEXT NOT NULL DEFAULT 'medium',
+        position INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_tasks_team ON tasks(team_id);
+      CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+      CREATE INDEX IF NOT EXISTS idx_tasks_assignee ON tasks(assignee);
+    `);
+    }
+    /** Add position column for existing databases that lack it. */
+    migrate() {
+        const columns = this.db.pragma("table_info(tasks)");
+        const hasPosition = columns.some((c) => c.name === "position");
+        if (!hasPosition) {
+            this.db.exec("ALTER TABLE tasks ADD COLUMN position INTEGER NOT NULL DEFAULT 0");
+            // Backfill: assign positions based on created_at DESC per status
+            for (const status of ["backlog", "todo", "in_progress", "done", "archived"]) {
+                const rows = this.db
+                    .prepare("SELECT id FROM tasks WHERE status = ? ORDER BY created_at DESC")
+                    .all(status);
+                const stmt = this.db.prepare("UPDATE tasks SET position = ? WHERE id = ?");
+                rows.forEach((row, i) => stmt.run(i, row.id));
+            }
+            logger.info("Migrated tasks table: added position column");
+        }
+        // Backfill NULL team_id → "default"
+        const nullCount = this.db
+            .prepare(`SELECT COUNT(*) AS n FROM tasks WHERE team_id IS NULL`)
+            .get();
+        if (nullCount.n > 0) {
+            this.db.prepare(`UPDATE tasks SET team_id = ? WHERE team_id IS NULL`).run(DEFAULT_TEAM_ID);
+            logger.info(`Migrated ${nullCount.n} tasks: set NULL team_id to '${DEFAULT_TEAM_ID}'`);
+        }
+    }
+    /** Get the next position value for a given status (appends to end). */
+    nextPosition(status) {
+        const row = this.db
+            .prepare("SELECT COALESCE(MAX(position), -1) + 1 AS next FROM tasks WHERE status = ?")
+            .get(status);
+        return row.next;
+    }
+    create(input) {
+        const now = Date.now();
+        const status = input.status ?? "todo";
+        const task = {
+            id: randomUUID().slice(0, 8),
+            teamId: input.teamId || DEFAULT_TEAM_ID,
+            title: input.title,
+            description: input.description ?? null,
+            status,
+            assignee: input.assignee ?? null,
+            priority: input.priority ?? "medium",
+            position: this.nextPosition(status),
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.db
+            .prepare(`INSERT INTO tasks (id, team_id, title, description, status, assignee, priority, position, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(task.id, task.teamId, task.title, task.description, task.status, task.assignee, task.priority, task.position, task.createdAt, task.updatedAt);
+        return task;
+    }
+    update(id, input) {
+        const existing = this.getById(id);
+        if (!existing)
+            return null;
+        // When status changes, assign position at end of new column
+        const statusChanged = input.status !== undefined && input.status !== existing.status;
+        const newPosition = statusChanged ? this.nextPosition(input.status) : existing.position;
+        const updated = {
+            ...existing,
+            ...(input.title !== undefined && { title: input.title }),
+            ...(input.description !== undefined && { description: input.description }),
+            ...(input.status !== undefined && { status: input.status }),
+            ...(input.assignee !== undefined && { assignee: input.assignee }),
+            ...(input.priority !== undefined && { priority: input.priority }),
+            ...(input.teamId !== undefined && { teamId: input.teamId || DEFAULT_TEAM_ID }),
+            position: newPosition,
+            updatedAt: Date.now(),
+        };
+        this.db
+            .prepare(`UPDATE tasks SET team_id = ?, title = ?, description = ?, status = ?, assignee = ?, priority = ?, position = ?, updated_at = ?
+         WHERE id = ?`)
+            .run(updated.teamId, updated.title, updated.description, updated.status, updated.assignee, updated.priority, updated.position, updated.updatedAt, id);
+        return updated;
+    }
+    /** Bulk-reorder tasks within a status column. Sets positions 0, 1, 2, ... */
+    reorder(status, orderedIds) {
+        const stmt = this.db.prepare("UPDATE tasks SET position = ?, updated_at = ? WHERE id = ? AND status = ?");
+        const now = Date.now();
+        const tx = this.db.transaction(() => {
+            orderedIds.forEach((id, i) => stmt.run(i, now, id, status));
+        });
+        tx();
+    }
+    delete(id) {
+        const info = this.db.prepare("DELETE FROM tasks WHERE id = ?").run(id);
+        return info.changes > 0;
+    }
+    getById(id) {
+        const row = this.db.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
+        return row ? toTask(row) : null;
+    }
+    list(filter = {}) {
+        const conditions = [];
+        const params = [];
+        if (filter.teamId) {
+            conditions.push("team_id = ?");
+            params.push(filter.teamId);
+        }
+        if (filter.status) {
+            conditions.push("status = ?");
+            params.push(filter.status);
+        }
+        else if (!filter.includeArchived) {
+            conditions.push("status != 'archived'");
+        }
+        if (filter.assignee) {
+            conditions.push("assignee = ?");
+            params.push(filter.assignee);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+        const rows = this.db
+            .prepare(`SELECT * FROM tasks ${where} ORDER BY position ASC`)
+            .all(...params);
+        return rows.map(toTask);
+    }
+    /** Bulk-archive all done tasks, optionally scoped to a team. */
+    archiveDone(teamId) {
+        if (teamId) {
+            const info = this.db
+                .prepare("UPDATE tasks SET status = 'archived', updated_at = ? WHERE status = 'done' AND team_id = ?")
+                .run(Date.now(), teamId);
+            return info.changes;
+        }
+        const info = this.db
+            .prepare("UPDATE tasks SET status = 'archived', updated_at = ? WHERE status = 'done'")
+            .run(Date.now());
+        return info.changes;
+    }
+    close() {
+        this.db.close();
+        logger.info("Task store closed");
+    }
+}
+function toTask(row) {
+    return {
+        id: row.id,
+        teamId: row.team_id || DEFAULT_TEAM_ID,
+        title: row.title,
+        description: row.description ?? null,
+        status: row.status,
+        assignee: row.assignee ?? null,
+        priority: row.priority,
+        position: row.position ?? 0,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}

package/dist/tasks/types.d.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+export declare const TASK_STATUSES: readonly ["backlog", "todo", "in_progress", "done", "archived"];
+export type TaskStatus = (typeof TASK_STATUSES)[number];
+export declare const TASK_PRIORITIES: readonly ["low", "medium", "high"];
+export type TaskPriority = (typeof TASK_PRIORITIES)[number];
+export interface Task {
+    id: string;
+    teamId: string;
+    title: string;
+    description: string | null;
+    status: TaskStatus;
+    assignee: string | null;
+    priority: TaskPriority;
+    position: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export declare const CreateTaskSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    teamId: z.ZodOptional<z.ZodString>;
+    assignee: z.ZodOptional<z.ZodString>;
+    priority: z.ZodDefault<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+    status: z.ZodDefault<z.ZodEnum<{
+        done: "done";
+        backlog: "backlog";
+        todo: "todo";
+        in_progress: "in_progress";
+    }>>;
+}, z.core.$strip>;
+export declare const UpdateTaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        done: "done";
+        backlog: "backlog";
+        todo: "todo";
+        in_progress: "in_progress";
+        archived: "archived";
+    }>>;
+    assignee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    priority: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+    teamId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const ListTasksSchema: z.ZodObject<{
+    teamId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        done: "done";
+        backlog: "backlog";
+        todo: "todo";
+        in_progress: "in_progress";
+        archived: "archived";
+    }>>;
+    assignee: z.ZodOptional<z.ZodString>;
+    includeArchived: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const ReorderTasksSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        done: "done";
+        backlog: "backlog";
+        todo: "todo";
+        in_progress: "in_progress";
+        archived: "archived";
+    }>;
+    orderedIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;

package/dist/tasks/types.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export const TASK_STATUSES = ["backlog", "todo", "in_progress", "done", "archived"];
+export const TASK_PRIORITIES = ["low", "medium", "high"];
+/** Visible on the kanban board (excludes archived). */
+const BOARD_STATUSES = ["backlog", "todo", "in_progress", "done"];
+export const CreateTaskSchema = z.object({
+    title: z.string().min(1),
+    description: z.string().optional(),
+    teamId: z.string().optional(),
+    assignee: z.string().optional(),
+    priority: z.enum(TASK_PRIORITIES).default("medium"),
+    status: z.enum(BOARD_STATUSES).default("todo"),
+});
+export const UpdateTaskSchema = z.object({
+    id: z.string(),
+    title: z.string().min(1).optional(),
+    description: z.string().nullable().optional(),
+    status: z.enum(TASK_STATUSES).optional(),
+    assignee: z.string().nullable().optional(),
+    priority: z.enum(TASK_PRIORITIES).optional(),
+    teamId: z.string().nullable().optional(),
+});
+export const ListTasksSchema = z.object({
+    teamId: z.string().optional(),
+    status: z.enum(TASK_STATUSES).optional(),
+    assignee: z.string().optional(),
+    includeArchived: z.boolean().optional(),
+});
+export const ReorderTasksSchema = z.object({
+    status: z.enum(TASK_STATUSES),
+    orderedIds: z.array(z.string()).min(1),
+});

package/dist/teams/store.d.ts

@@ -0,0 +1,78 @@
+import type { Team, AgentRow } from "./types.js";
+import type { TeamConfig } from "../config/agent-config.js";
+/** Max allowed length for team/agent names. */
+export declare const MAX_NAME_LENGTH = 128;
+/** Max allowed length for agent identity strings. */
+export declare const MAX_IDENTITY_LENGTH = 10000;
+/** Max allowed length for model strings. */
+export declare const MAX_MODEL_LENGTH = 256;
+/** Hex color pattern: #RRGGBB */
+export declare const HEX_COLOR_RE: RegExp;
+export interface CreateTeamInput {
+    /** Optional caller-provided id. If omitted, a random UUID is generated. */
+    id?: string;
+    name: string;
+    color?: string;
+    workspace?: string;
+    variables?: Record<string, string>;
+}
+export interface UpdateTeamInput {
+    name?: string;
+    color?: string;
+    workspace?: string;
+    variables?: Record<string, string>;
+}
+export interface CreateAgentInput {
+    /** Optional caller-provided id. If omitted, a random UUID is generated. */
+    id?: string;
+    name: string;
+    role: "orchestrator" | "worker";
+    model: string;
+    contextWindow?: number;
+    maxSteps?: number;
+    identity?: string;
+    tools?: string[];
+    timeout?: number;
+    templateId?: string | null;
+}
+export interface UpdateAgentInput {
+    name?: string;
+    role?: "orchestrator" | "worker";
+    model?: string;
+    contextWindow?: number;
+    maxSteps?: number;
+    identity?: string;
+    tools?: string[];
+    timeout?: number;
+    templateId?: string | null;
+}
+/**
+ * SQLite-backed persistence for teams and agents.
+ * Shares the same DB file as MemoryStore, TaskStore, etc.
+ */
+export declare class TeamStore {
+    private db;
+    private constructor();
+    static create(dbPath: string): Promise<TeamStore>;
+    private createSchema;
+    /** Run a function inside a SQLite transaction (all-or-nothing). */
+    transaction<T>(fn: () => T): T;
+    createTeam(input: CreateTeamInput): Team;
+    updateTeam(id: string, input: UpdateTeamInput): Team | null;
+    deleteTeam(id: string): boolean;
+    getTeamById(id: string): Team | null;
+    getTeamByName(name: string): Team | null;
+    listTeams(): Team[];
+    createAgent(teamId: string, input: CreateAgentInput): AgentRow;
+    updateAgent(id: string, input: UpdateAgentInput): AgentRow | null;
+    deleteAgent(id: string): boolean;
+    getAgentById(id: string): AgentRow | null;
+    listAgentsByTeam(teamId: string): AgentRow[];
+    getAgentByName(teamId: string, name: string): AgentRow | null;
+    /**
+     * Convert DB rows to the existing TeamConfig[] format so TeamRegistry
+     * constructor is unchanged. Uses a single JOIN query instead of N+1.
+     */
+    toTeamConfigs(): TeamConfig[];
+    close(): void;
+}