agent-office 0.4.5 → 0.4.7

package/dist/commands/task-board.d.ts

@@ -0,0 +1,29 @@
+interface TaskBoardOptions {
+    databaseUrl?: string;
+    sqlite?: string;
+}
+export declare function listTasks(options: TaskBoardOptions, cmdOptions: {
+    column?: string;
+}): Promise<void>;
+export declare function addTask(options: TaskBoardOptions, title: string, description: string, cmdOptions: {
+    assignee?: string;
+    column: string;
+    dependencies: string;
+}): Promise<void>;
+export declare function updateTask(options: TaskBoardOptions, idStr: string, cmdOptions: {
+    title?: string;
+    description?: string;
+    assignee?: string;
+    column?: string;
+    dependencies?: string;
+}): Promise<void>;
+export declare function deleteTask(options: TaskBoardOptions, idStr: string): Promise<void>;
+export declare function moveTask(options: TaskBoardOptions, idStr: string, column: string): Promise<void>;
+export declare function searchTasks(options: TaskBoardOptions, query: string, cmdOptions: {
+    assignee?: string;
+    column?: string;
+}): Promise<void>;
+export declare function assignTask(options: TaskBoardOptions, idStr: string, assignee: string): Promise<void>;
+export declare function showTask(options: TaskBoardOptions, idStr: string): Promise<void>;
+export declare function showStats(options: TaskBoardOptions): Promise<void>;
+export {};

package/dist/commands/task-board.js

@@ -0,0 +1,251 @@
+import { createPostgresqlStorage, createSqliteStorage } from "../db/index.js";
+import { runMigrations } from "../db/migrate.js";
+const VALID_COLUMNS = ["idea", "approved idea", "working on", "blocked", "ready for review", "done"];
+function validateColumn(column) {
+    if (!VALID_COLUMNS.includes(column)) {
+        console.error(`Error: invalid column "${column}". Valid columns are: ${VALID_COLUMNS.join(", ")}`);
+        process.exit(1);
+    }
+}
+async function getStorage(options) {
+    let storage;
+    if (options.sqlite) {
+        storage = createSqliteStorage(options.sqlite);
+    }
+    else if (options.databaseUrl) {
+        storage = createPostgresqlStorage(options.databaseUrl);
+    }
+    else {
+        console.error("Error: either --database-url or --sqlite is required");
+        process.exit(1);
+    }
+    // Run migrations
+    await runMigrations(storage);
+    return storage;
+}
+export async function listTasks(options, cmdOptions) {
+    const storage = await getStorage(options);
+    try {
+        const tasks = await storage.listTasks();
+        let filtered = tasks;
+        if (cmdOptions.column) {
+            validateColumn(cmdOptions.column);
+            filtered = tasks.filter(t => t.column === cmdOptions.column);
+        }
+        if (filtered.length === 0) {
+            console.log("No tasks found.");
+            return;
+        }
+        for (const task of filtered) {
+            console.log(`#${task.id} [${task.column}] ${task.title}`);
+            if (task.assignee)
+                console.log(`  Assignee: ${task.assignee}`);
+            console.log(`  Description: ${task.description}`);
+            if (task.dependencies.length > 0) {
+                console.log(`  Dependencies: ${task.dependencies.join(", ")}`);
+            }
+            console.log(`  Created: ${task.created_at.toISOString()}`);
+            console.log();
+        }
+    }
+    finally {
+        await storage.close();
+    }
+}
+export async function addTask(options, title, description, cmdOptions) {
+    const storage = await getStorage(options);
+    try {
+        validateColumn(cmdOptions.column);
+        const dependencies = cmdOptions.dependencies ? cmdOptions.dependencies.split(",").map(s => parseInt(s.trim(), 10)).filter(n => !isNaN(n)) : [];
+        const task = await storage.createTask(title, description, cmdOptions.assignee || null, cmdOptions.column, dependencies);
+        console.log(`Task #${task.id} created.`);
+    }
+    finally {
+        await storage.close();
+    }
+}
+export async function updateTask(options, idStr, cmdOptions) {
+    const storage = await getStorage(options);
+    try {
+        const id = parseInt(idStr, 10);
+        if (isNaN(id)) {
+            console.error("Error: invalid task ID");
+            process.exit(1);
+        }
+        const updates = {};
+        if (cmdOptions.title !== undefined)
+            updates.title = cmdOptions.title;
+        if (cmdOptions.description !== undefined)
+            updates.description = cmdOptions.description;
+        if (cmdOptions.assignee !== undefined)
+            updates.assignee = cmdOptions.assignee;
+        if (cmdOptions.column !== undefined) {
+            validateColumn(cmdOptions.column);
+            updates.column = cmdOptions.column;
+        }
+        if (cmdOptions.dependencies !== undefined) {
+            updates.dependencies = cmdOptions.dependencies.split(",").map(s => parseInt(s.trim(), 10)).filter(n => !isNaN(n));
+        }
+        const task = await storage.updateTask(id, updates);
+        if (!task) {
+            console.error("Error: task not found");
+            process.exit(1);
+        }
+        console.log(`Task #${task.id} updated.`);
+    }
+    finally {
+        await storage.close();
+    }
+}
+export async function deleteTask(options, idStr) {
+    const storage = await getStorage(options);
+    try {
+        const id = parseInt(idStr, 10);
+        if (isNaN(id)) {
+            console.error("Error: invalid task ID");
+            process.exit(1);
+        }
+        await storage.deleteTask(id);
+        console.log(`Task #${id} deleted.`);
+    }
+    finally {
+        await storage.close();
+    }
+}
+export async function moveTask(options, idStr, column) {
+    const storage = await getStorage(options);
+    try {
+        const id = parseInt(idStr, 10);
+        if (isNaN(id)) {
+            console.error("Error: invalid task ID");
+            process.exit(1);
+        }
+        validateColumn(column);
+        const task = await storage.updateTask(id, { column });
+        if (!task) {
+            console.error("Error: task not found");
+            process.exit(1);
+        }
+        console.log(`Task #${task.id} moved to "${column}".`);
+    }
+    finally {
+        await storage.close();
+    }
+}
+export async function searchTasks(options, query, cmdOptions) {
+    const storage = await getStorage(options);
+    try {
+        if (cmdOptions.column) {
+            validateColumn(cmdOptions.column);
+        }
+        const tasks = await storage.searchTasks(query, cmdOptions);
+        if (tasks.length === 0) {
+            console.log("No tasks found matching the search criteria.");
+            return;
+        }
+        console.log(`Found ${tasks.length} task(s) matching "${query}":`);
+        console.log();
+        for (const task of tasks) {
+            console.log(`#${task.id} [${task.column}] ${task.title}`);
+            if (task.assignee)
+                console.log(`  Assignee: ${task.assignee}`);
+            console.log(`  Description: ${task.description}`);
+            if (task.dependencies.length > 0) {
+                console.log(`  Dependencies: ${task.dependencies.join(", ")}`);
+            }
+            console.log(`  Created: ${task.created_at.toISOString()}`);
+            console.log();
+        }
+    }
+    finally {
+        await storage.close();
+    }
+}
+export async function assignTask(options, idStr, assignee) {
+    const storage = await getStorage(options);
+    try {
+        const id = parseInt(idStr, 10);
+        if (isNaN(id)) {
+            console.error("Error: invalid task ID");
+            process.exit(1);
+        }
+        const task = await storage.updateTask(id, { assignee });
+        if (!task) {
+            console.error("Error: task not found");
+            process.exit(1);
+        }
+        console.log(`Task #${task.id} assigned to "${assignee}".`);
+    }
+    finally {
+        await storage.close();
+    }
+}
+export async function showTask(options, idStr) {
+    const storage = await getStorage(options);
+    try {
+        const id = parseInt(idStr, 10);
+        if (isNaN(id)) {
+            console.error("Error: invalid task ID");
+            process.exit(1);
+        }
+        const task = await storage.getTaskById(id);
+        if (!task) {
+            console.error("Error: task not found");
+            process.exit(1);
+        }
+        console.log(`Task #${task.id}`);
+        console.log(`Title: ${task.title}`);
+        console.log(`Description: ${task.description}`);
+        console.log(`Column: ${task.column}`);
+        console.log(`Assignee: ${task.assignee || "Unassigned"}`);
+        console.log(`Dependencies: ${task.dependencies.length > 0 ? task.dependencies.join(", ") : "None"}`);
+        console.log(`Created: ${task.created_at.toISOString()}`);
+        console.log(`Updated: ${task.updated_at.toISOString()}`);
+    }
+    finally {
+        await storage.close();
+    }
+}
+export async function showStats(options) {
+    const storage = await getStorage(options);
+    try {
+        const tasks = await storage.listTasks();
+        const stats = {
+            total: tasks.length,
+            byColumn: {},
+            byAssignee: {},
+            unassigned: 0,
+        };
+        for (const task of tasks) {
+            // By column
+            stats.byColumn[task.column] = (stats.byColumn[task.column] || 0) + 1;
+            // By assignee
+            if (task.assignee) {
+                stats.byAssignee[task.assignee] = (stats.byAssignee[task.assignee] || 0) + 1;
+            }
+            else {
+                stats.unassigned++;
+            }
+        }
+        console.log("Task Board Statistics");
+        console.log("====================");
+        console.log(`Total tasks: ${stats.total}`);
+        console.log();
+        console.log("Tasks by column:");
+        for (const column of VALID_COLUMNS) {
+            const count = stats.byColumn[column] || 0;
+            console.log(`  ${column}: ${count}`);
+        }
+        console.log();
+        console.log("Tasks by assignee:");
+        if (stats.unassigned > 0) {
+            console.log(`  Unassigned: ${stats.unassigned}`);
+        }
+        for (const [assignee, count] of Object.entries(stats.byAssignee)) {
+            console.log(`  ${assignee}: ${count}`);
+        }
+    }
+    finally {
+        await storage.close();
+    }
+}

package/dist/commands/worker.d.ts

@@ -2,13 +2,14 @@ export declare function listCoworkers(token: string): Promise<void>;
 export declare function setStatus(token: string, status: string | null): Promise<void>;
 export declare function sendMessage(token: string, recipients: string[], body: string): Promise<void>;
 export declare function listCrons(token: string): Promise<void>;
-export declare function createCron(token: string, options: {
+export declare function requestCron(token: string, options: {
     name: string;
     schedule: string;
     message: string;
     respondTo: string;
     timezone?: string;
 }): Promise<void>;
+export declare function listCronRequests(token: string): Promise<void>;
 export declare function deleteCron(token: string, cronId: number): Promise<void>;
 export declare function enableCron(token: string, cronId: number): Promise<void>;
 export declare function disableCron(token: string, cronId: number): Promise<void>;

package/dist/commands/worker.js

@@ -95,10 +95,14 @@ export async function listCrons(token) {
     const crons = await fetchWorker(token, "/worker/crons");
     console.log(JSON.stringify(crons, null, 2));
 }
-export async function createCron(token, options) {
+export async function requestCron(token, options) {
     const finalMessage = `Action: ${options.message}\n\nWho to respond to when done: ${options.respondTo}`;
-    const cron = await postWorker(token, "/worker/crons", { name: options.name, schedule: options.schedule, message: finalMessage, timezone: options.timezone });
-    console.log(JSON.stringify(cron, null, 2));
+    const request = await postWorker(token, "/worker/cron-requests", { name: options.name, schedule: options.schedule, message: finalMessage, timezone: options.timezone });
+    console.log(JSON.stringify(request, null, 2));
+}
+export async function listCronRequests(token) {
+    const requests = await fetchWorker(token, "/worker/cron-requests");
+    console.log(JSON.stringify(requests, null, 2));
 }
 export async function deleteCron(token, cronId) {
     const { agentCode, serverUrl } = parseToken(token);

package/dist/db/index.d.ts

@@ -45,3 +45,26 @@ export interface CronHistoryRow {
     success: boolean;
     error_message: string | null;
 }
+export interface CronRequestRow {
+    id: number;
+    name: string;
+    session_name: string;
+    schedule: string;
+    timezone: string | null;
+    message: string;
+    status: "pending" | "approved" | "rejected";
+    requested_at: Date;
+    reviewed_at: Date | null;
+    reviewed_by: string | null;
+    reviewer_notes: string | null;
+}
+export interface TaskRow {
+    id: number;
+    title: string;
+    description: string;
+    assignee: string | null;
+    column: string;
+    dependencies: number[];
+    created_at: Date;
+    updated_at: Date;
+}

package/dist/db/postgresql-storage.d.ts

@@ -1,5 +1,5 @@
 import { AgentOfficeStorageBase } from "./storage-base.js";
-import type { SessionRow, ConfigRow, MessageRow, CronJobRow, CronHistoryRow, Sql } from "./index.js";
+import type { SessionRow, ConfigRow, MessageRow, CronJobRow, CronHistoryRow, CronRequestRow, TaskRow, Sql } from "./index.js";
 export declare class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase {
     private sql;
     constructor(sql: Sql);
@@ -43,6 +43,22 @@ export declare class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase
     cronJobExistsForSession(name: string, sessionName: string): Promise<boolean>;
     listCronHistory(cronJobId: number, limit: number): Promise<CronHistoryRow[]>;
     createCronHistory(cronJobId: number, executedAt: Date, success: boolean, errorMessage?: string): Promise<void>;
+    listCronRequests(filters?: {
+        status?: string;
+        sessionName?: string;
+    }): Promise<CronRequestRow[]>;
+    getCronRequestById(id: number): Promise<CronRequestRow | null>;
+    createCronRequest(name: string, sessionName: string, schedule: string, timezone: string | null, message: string): Promise<CronRequestRow>;
+    updateCronRequestStatus(id: number, status: "approved" | "rejected", reviewedBy: string, reviewerNotes?: string): Promise<CronRequestRow | null>;
+    listTasks(): Promise<TaskRow[]>;
+    getTaskById(id: number): Promise<TaskRow | null>;
+    createTask(title: string, description: string, assignee: string | null, column: string, dependencies: number[]): Promise<TaskRow>;
+    updateTask(id: number, updates: Partial<Pick<TaskRow, 'title' | 'description' | 'assignee' | 'column' | 'dependencies'>>): Promise<TaskRow | null>;
+    deleteTask(id: number): Promise<void>;
+    searchTasks(query: string, filters?: {
+        assignee?: string;
+        column?: string;
+    }): Promise<TaskRow[]>;
     runMigrations(): Promise<void>;
 }
 export declare function createPostgresqlStorage(databaseUrl: string): AgentOfficePostgresqlStorage;

package/dist/db/postgresql-storage.js

@@ -260,6 +260,142 @@ export class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase {
       `;
         }
     }
+    // Cron Requests
+    async listCronRequests(filters) {
+        if (filters?.status && filters?.sessionName) {
+            return this.sql `
+        SELECT id, name, session_name, schedule, timezone, message, status, requested_at, reviewed_at, reviewed_by, reviewer_notes
+        FROM cron_requests
+        WHERE status = ${filters.status} AND session_name = ${filters.sessionName}
+        ORDER BY requested_at DESC
+      `;
+        }
+        else if (filters?.status) {
+            return this.sql `
+        SELECT id, name, session_name, schedule, timezone, message, status, requested_at, reviewed_at, reviewed_by, reviewer_notes
+        FROM cron_requests
+        WHERE status = ${filters.status}
+        ORDER BY requested_at DESC
+      `;
+        }
+        else if (filters?.sessionName) {
+            return this.sql `
+        SELECT id, name, session_name, schedule, timezone, message, status, requested_at, reviewed_at, reviewed_by, reviewer_notes
+        FROM cron_requests
+        WHERE session_name = ${filters.sessionName}
+        ORDER BY requested_at DESC
+      `;
+        }
+        else {
+            return this.sql `
+        SELECT id, name, session_name, schedule, timezone, message, status, requested_at, reviewed_at, reviewed_by, reviewer_notes
+        FROM cron_requests
+        ORDER BY requested_at DESC
+      `;
+        }
+    }
+    async getCronRequestById(id) {
+        const [row] = await this.sql `
+      SELECT id, name, session_name, schedule, timezone, message, status, requested_at, reviewed_at, reviewed_by, reviewer_notes
+      FROM cron_requests WHERE id = ${id}
+    `;
+        return row ?? null;
+    }
+    async createCronRequest(name, sessionName, schedule, timezone, message) {
+        const [row] = await this.sql `
+      INSERT INTO cron_requests (name, session_name, schedule, timezone, message)
+      VALUES (${name}, ${sessionName}, ${schedule}, ${timezone}, ${message})
+      RETURNING id, name, session_name, schedule, timezone, message, status, requested_at, reviewed_at, reviewed_by, reviewer_notes
+    `;
+        return row;
+    }
+    async updateCronRequestStatus(id, status, reviewedBy, reviewerNotes) {
+        const [row] = await this.sql `
+      UPDATE cron_requests
+      SET status = ${status}, reviewed_at = NOW(), reviewed_by = ${reviewedBy}, reviewer_notes = ${reviewerNotes ?? null}
+      WHERE id = ${id}
+      RETURNING id, name, session_name, schedule, timezone, message, status, requested_at, reviewed_at, reviewed_by, reviewer_notes
+    `;
+        return row ?? null;
+    }
+    // Tasks
+    async listTasks() {
+        return this.sql `
+      SELECT id, title, description, assignee, column_name as column, dependencies, created_at, updated_at
+      FROM tasks
+      ORDER BY created_at DESC
+    `;
+    }
+    async getTaskById(id) {
+        const [row] = await this.sql `
+      SELECT id, title, description, assignee, column_name as column, dependencies, created_at, updated_at
+      FROM tasks WHERE id = ${id}
+    `;
+        return row ?? null;
+    }
+    async createTask(title, description, assignee, column, dependencies) {
+        const [row] = await this.sql `
+      INSERT INTO tasks (title, description, assignee, column_name, dependencies)
+      VALUES (${title}, ${description}, ${assignee}, ${column}, ${JSON.stringify(dependencies)}::jsonb)
+      RETURNING id, title, description, assignee, column_name as column, dependencies, created_at, updated_at
+    `;
+        return row;
+    }
+    async updateTask(id, updates) {
+        const setParts = [];
+        const values = [];
+        if (updates.title !== undefined) {
+            setParts.push('title = ?');
+            values.push(updates.title);
+        }
+        if (updates.description !== undefined) {
+            setParts.push('description = ?');
+            values.push(updates.description);
+        }
+        if (updates.assignee !== undefined) {
+            setParts.push('assignee = ?');
+            values.push(updates.assignee);
+        }
+        if (updates.column !== undefined) {
+            setParts.push('column_name = ?');
+            values.push(updates.column);
+        }
+        if (updates.dependencies !== undefined) {
+            setParts.push('dependencies = ?');
+            values.push(JSON.stringify(updates.dependencies));
+        }
+        if (setParts.length === 0)
+            return this.getTaskById(id);
+        setParts.push('updated_at = NOW()');
+        const sql = `UPDATE tasks SET ${setParts.join(', ')} WHERE id = ? RETURNING id, title, description, assignee, column_name as column, dependencies, created_at, updated_at`;
+        values.push(id);
+        const [row] = await this.sql.unsafe(sql, values);
+        return row ?? null;
+    }
+    async deleteTask(id) {
+        await this.sql `DELETE FROM tasks WHERE id = ${id}`;
+    }
+    async searchTasks(query, filters) {
+        const conditions = [];
+        const params = [];
+        conditions.push(`(title ILIKE $${params.length + 1} OR description ILIKE $${params.length + 1})`);
+        params.push(`${query}%`);
+        if (filters?.assignee) {
+            conditions.push(`assignee = $${params.length + 1}`);
+            params.push(filters.assignee);
+        }
+        if (filters?.column) {
+            conditions.push(`column_name = $${params.length + 1}`);
+            params.push(filters.column);
+        }
+        const sql = `
+      SELECT id, title, description, assignee, column_name as column, dependencies, created_at, updated_at
+      FROM tasks
+      WHERE ${conditions.join(' AND ')}
+      ORDER BY created_at DESC
+    `;
+        return this.sql.unsafe(sql, params);
+    }
     async runMigrations() {
         const MIGRATIONS = [
             {
@@ -368,6 +504,45 @@ export class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase {
                 name: "add_notified_to_messages",
                 sql: `
           ALTER TABLE messages ADD COLUMN IF NOT EXISTS notified BOOLEAN NOT NULL DEFAULT FALSE;
+        `,
+            },
+            {
+                version: 10,
+                name: "create_tasks_table",
+                sql: `
+          CREATE TABLE IF NOT EXISTS tasks (
+            id           SERIAL PRIMARY KEY,
+            title        TEXT NOT NULL,
+            description  TEXT NOT NULL,
+            assignee     TEXT,
+            column_name  TEXT NOT NULL,
+            dependencies JSONB NOT NULL DEFAULT '[]'::jsonb,
+            created_at   TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+            updated_at   TIMESTAMPTZ NOT NULL DEFAULT NOW()
+          );
+          CREATE INDEX IF NOT EXISTS idx_tasks_assignee ON tasks(assignee);
+          CREATE INDEX IF NOT EXISTS idx_tasks_column ON tasks(column_name);
+        `,
+            },
+            {
+                version: 11,
+                name: "create_cron_requests_table",
+                sql: `
+          CREATE TABLE IF NOT EXISTS cron_requests (
+            id              SERIAL PRIMARY KEY,
+            name            VARCHAR(255) NOT NULL,
+            session_name    VARCHAR(255) NOT NULL REFERENCES sessions(name) ON DELETE CASCADE,
+            schedule        TEXT NOT NULL,
+            timezone        VARCHAR(100),
+            message         TEXT NOT NULL,
+            status          VARCHAR(20) NOT NULL DEFAULT 'pending',
+            requested_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+            reviewed_at     TIMESTAMPTZ,
+            reviewed_by     TEXT,
+            reviewer_notes  TEXT
+          );
+          CREATE INDEX IF NOT EXISTS idx_cron_requests_session_name ON cron_requests(session_name);
+          CREATE INDEX IF NOT EXISTS idx_cron_requests_status ON cron_requests(status);
         `,
             },
         ];

package/dist/db/sqlite-storage.d.ts

@@ -1,6 +1,6 @@
 import Database from "better-sqlite3";
 import { AgentOfficeStorageBase } from "./storage-base.js";
-import type { SessionRow, ConfigRow, MessageRow, CronJobRow, CronHistoryRow } from "./index.js";
+import type { SessionRow, ConfigRow, MessageRow, CronJobRow, CronHistoryRow, CronRequestRow, TaskRow } from "./index.js";
 export declare class AgentOfficeSqliteStorage extends AgentOfficeStorageBase {
     private db;
     constructor(db: Database.Database);
@@ -44,6 +44,22 @@ export declare class AgentOfficeSqliteStorage extends AgentOfficeStorageBase {
     cronJobExistsForSession(name: string, sessionName: string): Promise<boolean>;
     listCronHistory(cronJobId: number, limit: number): Promise<CronHistoryRow[]>;
     createCronHistory(cronJobId: number, executedAt: Date, success: boolean, errorMessage?: string): Promise<void>;
+    listCronRequests(filters?: {
+        status?: string;
+        sessionName?: string;
+    }): Promise<CronRequestRow[]>;
+    getCronRequestById(id: number): Promise<CronRequestRow | null>;
+    createCronRequest(name: string, sessionName: string, schedule: string, timezone: string | null, message: string): Promise<CronRequestRow>;
+    updateCronRequestStatus(id: number, status: "approved" | "rejected", reviewedBy: string, reviewerNotes?: string): Promise<CronRequestRow | null>;
+    listTasks(): Promise<TaskRow[]>;
+    getTaskById(id: number): Promise<TaskRow | null>;
+    createTask(title: string, description: string, assignee: string | null, column: string, dependencies: number[]): Promise<TaskRow>;
+    updateTask(id: number, updates: Partial<Pick<TaskRow, 'title' | 'description' | 'assignee' | 'column' | 'dependencies'>>): Promise<TaskRow | null>;
+    deleteTask(id: number): Promise<void>;
+    searchTasks(query: string, filters?: {
+        assignee?: string;
+        column?: string;
+    }): Promise<TaskRow[]>;
     runMigrations(): Promise<void>;
 }
 export declare function createSqliteStorage(databasePath: string): AgentOfficeSqliteStorage;