stagent 0.1.0

package/src/lib/documents/processors/pdf.ts

@@ -0,0 +1,12 @@
+import { readFile } from "fs/promises";
+import type { ProcessorResult } from "../registry";
+
+/** Extract text from PDF files using pdf-parse v2 */
+export async function processPdf(filePath: string): Promise<ProcessorResult> {
+  const { PDFParse } = await import("pdf-parse");
+  const buffer = await readFile(filePath);
+  const parser = new PDFParse({ data: new Uint8Array(buffer) });
+  const result = await parser.getText();
+  await parser.destroy();
+  return { extractedText: result.text };
+}

package/src/lib/documents/processors/spreadsheet.ts

@@ -0,0 +1,18 @@
+import { readFile } from "fs/promises";
+import type { ProcessorResult } from "../registry";
+
+/** Parse XLSX/CSV to a text table representation */
+export async function processSpreadsheet(filePath: string): Promise<ProcessorResult> {
+  const XLSX = await import("xlsx");
+  const buffer = await readFile(filePath);
+  const workbook = XLSX.read(buffer, { type: "buffer" });
+
+  const sheets: string[] = [];
+  for (const sheetName of workbook.SheetNames) {
+    const sheet = workbook.Sheets[sheetName];
+    const csv = XLSX.utils.sheet_to_csv(sheet);
+    sheets.push(`--- Sheet: ${sheetName} ---\n${csv}`);
+  }
+
+  return { extractedText: sheets.join("\n\n") };
+}

package/src/lib/documents/processors/text.ts

@@ -0,0 +1,8 @@
+import { readFile } from "fs/promises";
+import type { ProcessorResult } from "../registry";
+
+/** Read plain text, markdown, code, and config files directly */
+export async function processText(filePath: string): Promise<ProcessorResult> {
+  const content = await readFile(filePath, "utf-8");
+  return { extractedText: content };
+}

package/src/lib/documents/registry.ts

@@ -0,0 +1,25 @@
+/**
+ * Extensible document processor registry.
+ * Maps MIME types to processor functions for text extraction.
+ */
+
+export interface ProcessorResult {
+  extractedText: string;
+  processedPath?: string;
+}
+
+export type Processor = (filePath: string) => Promise<ProcessorResult>;
+
+const registry = new Map<string, Processor>();
+
+export function registerProcessor(mimeType: string, processor: Processor): void {
+  registry.set(mimeType, processor);
+}
+
+export function getProcessor(mimeType: string): Processor | undefined {
+  return registry.get(mimeType);
+}
+
+export function hasProcessor(mimeType: string): boolean {
+  return registry.has(mimeType);
+}

package/src/lib/notifications/actionable.ts

@@ -0,0 +1,108 @@
+import { and, desc, eq, isNull } from "drizzle-orm";
+
+import { db } from "@/lib/db";
+import { notifications, tasks, workflows } from "@/lib/db/schema";
+import {
+  buildPermissionSummary,
+  getPermissionKindLabel,
+  parseNotificationToolInput,
+  type PermissionToolInput,
+} from "@/lib/notifications/permissions";
+
+export const APPROVAL_ACTION_IDS = [
+  "allow_once",
+  "always_allow",
+  "deny",
+  "open_inbox",
+] as const;
+
+export type ApprovalActionId = (typeof APPROVAL_ACTION_IDS)[number];
+export type NotificationChannelId = "in_app" | "browser" | "tauri";
+
+export interface ActionableNotificationPayload {
+  notificationId: string;
+  taskId: string | null;
+  workflowId: string | null;
+  toolName: string | null;
+  permissionLabel: string;
+  compactSummary: string;
+  deepLink: string;
+  supportedActionIds: ApprovalActionId[];
+}
+
+export interface PendingApprovalPayload extends ActionableNotificationPayload {
+  channel: "in_app";
+  title: string;
+  body: string | null;
+  taskTitle: string | null;
+  workflowName: string | null;
+  toolInput: PermissionToolInput | null;
+  createdAt: string;
+  read: boolean;
+}
+
+export interface ActionableNotificationChannelAdapter {
+  channelId: NotificationChannelId;
+  present(payload: ActionableNotificationPayload): void | Promise<void>;
+  dismiss?(notificationId: string): void | Promise<void>;
+}
+
+function buildDeepLink(taskId: string | null, workflowId: string | null): string {
+  if (taskId) return `/tasks/${taskId}`;
+  if (workflowId) return `/workflows/${workflowId}`;
+  return "/inbox";
+}
+
+export async function listPendingApprovalPayloads(
+  limit = 20
+): Promise<PendingApprovalPayload[]> {
+  const rows = await db
+    .select({
+      notificationId: notifications.id,
+      taskId: notifications.taskId,
+      type: notifications.type,
+      title: notifications.title,
+      body: notifications.body,
+      read: notifications.read,
+      toolName: notifications.toolName,
+      toolInput: notifications.toolInput,
+      createdAt: notifications.createdAt,
+      taskTitle: tasks.title,
+      workflowId: tasks.workflowId,
+      workflowName: workflows.name,
+    })
+    .from(notifications)
+    .leftJoin(tasks, eq(tasks.id, notifications.taskId))
+    .leftJoin(workflows, eq(workflows.id, tasks.workflowId))
+    .where(
+      and(
+        eq(notifications.type, "permission_required"),
+        isNull(notifications.response)
+      )
+    )
+    .orderBy(desc(notifications.createdAt))
+    .limit(limit);
+
+  return rows.map((row) => {
+    const parsedInput = parseNotificationToolInput(row.toolInput);
+
+    return {
+      channel: "in_app",
+      notificationId: row.notificationId,
+      taskId: row.taskId,
+      workflowId: row.workflowId,
+      toolName: row.toolName,
+      permissionLabel: getPermissionKindLabel(row.toolName),
+      compactSummary: buildPermissionSummary(row.toolName, parsedInput),
+      deepLink: buildDeepLink(row.taskId, row.workflowId),
+      supportedActionIds: [...APPROVAL_ACTION_IDS],
+      title: row.title,
+      body: row.body,
+      taskTitle: row.taskTitle,
+      workflowName: row.workflowName,
+      toolInput: parsedInput as PermissionToolInput | null,
+      createdAt: row.createdAt.toISOString(),
+      read: row.read,
+    };
+  });
+}

package/src/lib/notifications/permissions.ts

@@ -0,0 +1,169 @@
+export type PermissionToolInput = Record<string, unknown>;
+
+function truncate(value: string, max = 120): string {
+  if (value.length <= max) return value;
+  return `${value.slice(0, max - 1)}…`;
+}
+
+function toDisplayString(value: unknown): string {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+
+export function parseNotificationToolInput(
+  toolInput: string | null
+): PermissionToolInput | null {
+  if (!toolInput) return null;
+
+  try {
+    const parsed = JSON.parse(toolInput);
+    return parsed && typeof parsed === "object"
+      ? (parsed as PermissionToolInput)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+export function getPermissionKindLabel(toolName: string | null): string {
+  if (!toolName) return "Tool";
+
+  if (toolName.startsWith("mcp__")) {
+    const [, server = "server", tool = "tool"] = toolName.split("__");
+    return `MCP ${server}/${tool}`;
+  }
+
+  return toolName;
+}
+
+export function buildPermissionPattern(
+  toolName: string,
+  input: PermissionToolInput
+): string {
+  if (toolName === "Bash" && typeof input.command === "string") {
+    const firstWord = input.command.trim().split(/\s+/)[0];
+    return `Bash(command:${firstWord} *)`;
+  }
+
+  if (toolName === "bash" && typeof input.cmd === "string") {
+    const firstWord = input.cmd.trim().split(/\s+/)[0];
+    return `bash(command:${firstWord} *)`;
+  }
+
+  return toolName;
+}
+
+export function buildPermissionSummary(
+  toolName: string | null,
+  input: PermissionToolInput | null
+): string {
+  if (!input) return "Review the requested tool invocation.";
+
+  if (toolName === "Bash" || toolName === "bash") {
+    const command = input.command ?? input.cmd;
+    if (typeof command === "string" && command.trim().length > 0) {
+      return truncate(command.trim());
+    }
+  }
+
+  if (
+    toolName === "Read" ||
+    toolName === "Write" ||
+    toolName === "Edit" ||
+    toolName === "read" ||
+    toolName === "write" ||
+    toolName === "edit"
+  ) {
+    const path = input.file_path ?? input.path;
+    if (typeof path === "string" && path.trim().length > 0) {
+      return truncate(path.trim());
+    }
+  }
+
+  if (toolName?.startsWith("mcp__")) {
+    const entries = Object.entries(input);
+    const firstString = entries.find(([, value]) => typeof value === "string");
+    if (firstString && typeof firstString[1] === "string") {
+      return truncate(firstString[1]);
+    }
+
+    if (entries.length > 0) {
+      const [key, value] = entries[0];
+      return truncate(`${key}: ${toDisplayString(value)}`);
+    }
+  }
+
+  const entries = Object.entries(input);
+  const firstString = entries.find(([, value]) => typeof value === "string");
+  if (firstString && typeof firstString[1] === "string") {
+    return truncate(firstString[1]);
+  }
+
+  if (entries.length > 0) {
+    const [key, value] = entries[0];
+    return truncate(`${key}: ${toDisplayString(value)}`);
+  }
+
+  return "Review the requested tool invocation.";
+}
+
+export function getPermissionDetailEntries(
+  toolName: string | null,
+  input: PermissionToolInput | null
+): Array<{ label: string; value: string }> {
+  if (!input) return [];
+
+  if (toolName === "Bash" || toolName === "bash") {
+    const command = input.command ?? input.cmd;
+    if (typeof command === "string") {
+      return [{ label: "Command", value: command }];
+    }
+  }
+
+  if (
+    toolName === "Read" ||
+    toolName === "Write" ||
+    toolName === "Edit" ||
+    toolName === "read" ||
+    toolName === "write" ||
+    toolName === "edit"
+  ) {
+    const path = input.file_path ?? input.path;
+    if (typeof path === "string") {
+      return [{ label: "Path", value: path }];
+    }
+  }
+
+  return Object.entries(input)
+    .slice(0, 6)
+    .map(([key, value]) => ({
+      label: key,
+      value: toDisplayString(value),
+    }));
+}
+
+export function getPermissionResponseLabel(response: string | null): string | null {
+  if (!response) return null;
+
+  try {
+    const parsed = JSON.parse(response) as {
+      behavior?: "allow" | "deny";
+      alwaysAllow?: boolean;
+    };
+
+    if (parsed.behavior === "allow") {
+      return parsed.alwaysAllow ? "Always allowed" : "Allowed";
+    }
+
+    if (parsed.behavior === "deny") {
+      return "Denied";
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}

package/src/lib/queries/chart-data.ts

@@ -0,0 +1,184 @@
+import { db } from "@/lib/db";
+import { tasks, projects, agentLogs, notifications } from "@/lib/db/schema";
+import { sql, eq, and, gte } from "drizzle-orm";
+
+/** Helper: generate array of date strings (YYYY-MM-DD) for the last N days */
+function lastNDays(days: number): string[] {
+  const result: string[] = [];
+  const now = new Date();
+  for (let i = days - 1; i >= 0; i--) {
+    const d = new Date(now);
+    d.setDate(d.getDate() - i);
+    result.push(d.toISOString().slice(0, 10));
+  }
+  return result;
+}
+
+/** Helper: merge query results with gap-filled date array */
+function gapFill(
+  dates: string[],
+  rows: { date: string; count: number }[]
+): number[] {
+  const map = new Map(rows.map((r) => [r.date, r.count]));
+  return dates.map((d) => map.get(d) ?? 0);
+}
+
+/** Unix timestamp for N days ago at midnight */
+function daysAgoTimestamp(days: number): Date {
+  const d = new Date();
+  d.setDate(d.getDate() - days);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+
+/**
+ * 7-day task completion counts (one number per day).
+ */
+export async function getCompletionsByDay(days = 7): Promise<number[]> {
+  const dates = lastNDays(days);
+  const since = daysAgoTimestamp(days);
+
+  const rows = await db
+    .select({
+      date: sql<string>`strftime('%Y-%m-%d', ${tasks.updatedAt} , 'unixepoch')`,
+      count: sql<number>`count(*)`,
+    })
+    .from(tasks)
+    .where(and(eq(tasks.status, "completed"), gte(tasks.updatedAt, since)))
+    .groupBy(sql`strftime('%Y-%m-%d', ${tasks.updatedAt} , 'unixepoch')`);
+
+  return gapFill(dates, rows);
+}
+
+/**
+ * 7-day task creation counts.
+ */
+export async function getTaskCreationsByDay(days = 7): Promise<number[]> {
+  const dates = lastNDays(days);
+  const since = daysAgoTimestamp(days);
+
+  const rows = await db
+    .select({
+      date: sql<string>`strftime('%Y-%m-%d', ${tasks.createdAt} , 'unixepoch')`,
+      count: sql<number>`count(*)`,
+    })
+    .from(tasks)
+    .where(gte(tasks.createdAt, since))
+    .groupBy(sql`strftime('%Y-%m-%d', ${tasks.createdAt} , 'unixepoch')`);
+
+  return gapFill(dates, rows);
+}
+
+/**
+ * 7-day count of distinct active projects with task activity each day.
+ * Shows how many active projects had task updates per day.
+ */
+export async function getActiveProjectActivityByDay(days = 7): Promise<number[]> {
+  const dates = lastNDays(days);
+  const since = daysAgoTimestamp(days);
+
+  const rows = await db
+    .select({
+      date: sql<string>`strftime('%Y-%m-%d', ${tasks.updatedAt} , 'unixepoch')`,
+      count: sql<number>`count(distinct ${tasks.projectId})`,
+    })
+    .from(tasks)
+    .innerJoin(projects, eq(tasks.projectId, projects.id))
+    .where(and(eq(projects.status, "active"), gte(tasks.updatedAt, since)))
+    .groupBy(sql`strftime('%Y-%m-%d', ${tasks.updatedAt} , 'unixepoch')`);
+
+  return gapFill(dates, rows);
+}
+
+/**
+ * 24-hour agent activity (log counts per hour for the last 24h).
+ * Returns 24 numbers (index 0 = 24h ago, index 23 = current hour).
+ */
+export async function getAgentActivityByHour(): Promise<number[]> {
+  const since = new Date(Date.now() - 24 * 60 * 60 * 1000);
+
+  const rows = await db
+    .select({
+      hour: sql<number>`cast(strftime('%H', ${agentLogs.timestamp} , 'unixepoch') as integer)`,
+      count: sql<number>`count(*)`,
+    })
+    .from(agentLogs)
+    .where(gte(agentLogs.timestamp, since))
+    .groupBy(sql`strftime('%H', ${agentLogs.timestamp} , 'unixepoch')`);
+
+  // Build 24-slot array from current hour backward
+  const nowHour = new Date().getHours();
+  const hourMap = new Map(rows.map((r) => [r.hour, r.count]));
+  const result: number[] = [];
+  for (let i = 0; i < 24; i++) {
+    const h = (nowHour - 23 + i + 24) % 24;
+    result.push(hourMap.get(h) ?? 0);
+  }
+  return result;
+}
+
+/**
+ * 7-day notification counts.
+ */
+export async function getNotificationsByDay(days = 7): Promise<number[]> {
+  const dates = lastNDays(days);
+  const since = daysAgoTimestamp(days);
+
+  const rows = await db
+    .select({
+      date: sql<string>`strftime('%Y-%m-%d', ${notifications.createdAt} , 'unixepoch')`,
+      count: sql<number>`count(*)`,
+    })
+    .from(notifications)
+    .where(gte(notifications.createdAt, since))
+    .groupBy(sql`strftime('%Y-%m-%d', ${notifications.createdAt} , 'unixepoch')`);
+
+  return gapFill(dates, rows);
+}
+
+/**
+ * N-day completion trend for a specific project.
+ */
+export async function getProjectCompletionTrend(
+  projectId: string,
+  days = 14
+): Promise<number[]> {
+  const dates = lastNDays(days);
+  const since = daysAgoTimestamp(days);
+
+  const rows = await db
+    .select({
+      date: sql<string>`strftime('%Y-%m-%d', ${tasks.updatedAt} , 'unixepoch')`,
+      count: sql<number>`count(*)`,
+    })
+    .from(tasks)
+    .where(
+      and(
+        eq(tasks.projectId, projectId),
+        eq(tasks.status, "completed"),
+        gte(tasks.updatedAt, since)
+      )
+    )
+    .groupBy(sql`strftime('%Y-%m-%d', ${tasks.updatedAt} , 'unixepoch')`);
+
+  return gapFill(dates, rows);
+}
+
+/**
+ * Status distribution for a project.
+ * Returns { status: string, count: number }[] for stacked bar segments.
+ */
+export async function getProjectStatusDistribution(
+  projectId: string
+): Promise<{ status: string; count: number }[]> {
+  const rows = await db
+    .select({
+      status: tasks.status,
+      count: sql<number>`count(*)`,
+    })
+    .from(tasks)
+    .where(eq(tasks.projectId, projectId))
+    .groupBy(tasks.status);
+
+  return rows;
+}

package/src/lib/schedules/interval-parser.ts

@@ -0,0 +1,110 @@
+/**
+ * Parse human-friendly interval strings into 5-field cron expressions.
+ *
+ * Supported formats:
+ *   - `5m`  → every 5 minutes  → `*​/5 * * * *`
+ *   - `2h`  → every 2 hours    → `0 *​/2 * * *`
+ *   - `1d`  → daily at 9am     → `0 9 * * *`
+ *   - `30s` → not supported (sub-minute precision is not allowed)
+ *   - Raw cron expressions (5 fields) are returned as-is after validation
+ */
+
+import { CronExpressionParser } from "cron-parser";
+
+const INTERVAL_RE = /^(\d+)\s*(m|min|mins|minutes?|h|hr|hrs|hours?|d|day|days)$/i;
+
+/**
+ * Convert a human-friendly interval string or raw cron expression into a
+ * validated 5-field cron expression.
+ *
+ * @returns The cron expression string
+ * @throws  If the input cannot be parsed
+ */
+export function parseInterval(input: string): string {
+  const trimmed = input.trim();
+  if (!trimmed) throw new Error("Interval cannot be empty");
+
+  // Try as human-friendly shorthand first
+  const match = trimmed.match(INTERVAL_RE);
+  if (match) {
+    const value = parseInt(match[1], 10);
+    const unit = match[2].toLowerCase().charAt(0); // m, h, or d
+
+    if (value <= 0) throw new Error("Interval value must be positive");
+
+    switch (unit) {
+      case "m":
+        if (value > 59) throw new Error("Minute interval must be 1-59");
+        return value === 1 ? "* * * * *" : `*/${value} * * * *`;
+      case "h":
+        if (value > 23) throw new Error("Hour interval must be 1-23");
+        return value === 1 ? "0 * * * *" : `0 */${value} * * *`;
+      case "d":
+        if (value === 1) return "0 9 * * *"; // daily at 9am
+        if (value > 31) throw new Error("Day interval must be 1-31");
+        return `0 9 */${value} * *`;
+      default:
+        throw new Error(`Unknown unit: ${unit}`);
+    }
+  }
+
+  // Try as raw cron expression (5 fields)
+  const fields = trimmed.split(/\s+/);
+  if (fields.length === 5) {
+    // Validate by parsing — cron-parser will throw if invalid
+    CronExpressionParser.parse(trimmed);
+    return trimmed;
+  }
+
+  throw new Error(
+    `Cannot parse interval "${trimmed}". Use formats like 5m, 2h, 1d, or a 5-field cron expression.`
+  );
+}
+
+/**
+ * Compute the next fire time from a cron expression.
+ *
+ * @param cronExpression  A valid 5-field cron expression
+ * @param from            Base date to compute from (defaults to now)
+ * @returns               The next fire Date
+ */
+export function computeNextFireTime(cronExpression: string, from?: Date): Date {
+  const expr = CronExpressionParser.parse(cronExpression, {
+    currentDate: from ?? new Date(),
+  });
+  return expr.next().toDate();
+}
+
+/**
+ * Generate a human-readable description of a cron expression.
+ */
+export function describeCron(cronExpression: string): string {
+  const fields = cronExpression.split(/\s+/);
+  if (fields.length !== 5) return cronExpression;
+
+  const [minute, hour, dom, , dow] = fields;
+
+  // Common patterns
+  if (minute === "*" && hour === "*" && dom === "*" && dow === "*") {
+    return "Every minute";
+  }
+  if (minute.startsWith("*/") && hour === "*" && dom === "*" && dow === "*") {
+    const mins = minute.slice(2);
+    return `Every ${mins} minutes`;
+  }
+  if (minute === "0" && hour === "*" && dom === "*" && dow === "*") {
+    return "Every hour";
+  }
+  if (minute === "0" && hour.startsWith("*/") && dom === "*" && dow === "*") {
+    const hrs = hour.slice(2);
+    return `Every ${hrs} hours`;
+  }
+  if (minute === "0" && hour === "9" && dom === "*" && dow === "*") {
+    return "Daily at 9:00 AM";
+  }
+  if (minute === "0" && hour === "9" && dom === "*" && dow === "1-5") {
+    return "Weekdays at 9:00 AM";
+  }
+
+  return cronExpression;
+}