@siftd/connect-agent 0.2.37 → 0.2.39

package/dist/core/task-queue.js

@@ -0,0 +1,248 @@
+/**
+ * Lia's Internal Task Queue
+ *
+ * This manages Lia's own todo list - separate from user /todos.
+ * Allows async message processing where users can keep sending
+ * while Lia works through her queue.
+ */
+/**
+ * Lia's task queue - manages her internal todo list
+ */
+export class LiaTaskQueue {
+    tasks = new Map();
+    plans = new Map();
+    queue = []; // Task IDs in priority order
+    currentTask = null;
+    isProcessing = false;
+    // Callbacks for real-time updates
+    onTaskUpdate;
+    onPlanUpdate;
+    processTask;
+    constructor(options) {
+        this.onTaskUpdate = options?.onTaskUpdate;
+        this.onPlanUpdate = options?.onPlanUpdate;
+        this.processTask = options?.processTask;
+    }
+    /**
+     * Add a new task to the queue
+     */
+    addTask(task) {
+        const newTask = {
+            ...task,
+            id: `task_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            status: 'pending',
+            createdAt: new Date(),
+        };
+        this.tasks.set(newTask.id, newTask);
+        this.insertByPriority(newTask.id, newTask.priority);
+        this.onTaskUpdate?.(newTask);
+        // Auto-start processing if not already running
+        if (!this.isProcessing) {
+            this.startProcessing();
+        }
+        return newTask;
+    }
+    /**
+     * Insert task ID into queue based on priority
+     */
+    insertByPriority(taskId, priority) {
+        const priorityOrder = {
+            urgent: 0,
+            high: 1,
+            normal: 2,
+            low: 3,
+        };
+        const taskPriority = priorityOrder[priority];
+        let insertIndex = this.queue.length;
+        for (let i = 0; i < this.queue.length; i++) {
+            const existingTask = this.tasks.get(this.queue[i]);
+            if (existingTask && priorityOrder[existingTask.priority] > taskPriority) {
+                insertIndex = i;
+                break;
+            }
+        }
+        this.queue.splice(insertIndex, 0, taskId);
+    }
+    /**
+     * Start processing the queue
+     */
+    async startProcessing() {
+        if (this.isProcessing)
+            return;
+        this.isProcessing = true;
+        while (this.queue.length > 0) {
+            const taskId = this.queue.shift();
+            if (!taskId)
+                continue;
+            const task = this.tasks.get(taskId);
+            if (!task || task.status === 'cancelled')
+                continue;
+            this.currentTask = taskId;
+            task.status = 'in_progress';
+            task.startedAt = new Date();
+            this.onTaskUpdate?.(task);
+            try {
+                if (this.processTask) {
+                    const result = await this.processTask(task);
+                    task.result = result;
+                    task.status = 'completed';
+                }
+                else {
+                    task.status = 'failed';
+                    task.error = 'No task processor configured';
+                }
+            }
+            catch (error) {
+                task.status = 'failed';
+                task.error = error instanceof Error ? error.message : String(error);
+            }
+            task.completedAt = new Date();
+            this.currentTask = null;
+            this.onTaskUpdate?.(task);
+        }
+        this.isProcessing = false;
+    }
+    /**
+     * Get the current task being processed
+     */
+    getCurrentTask() {
+        return this.currentTask ? this.tasks.get(this.currentTask) || null : null;
+    }
+    /**
+     * Get all pending tasks
+     */
+    getPendingTasks() {
+        return this.queue
+            .map(id => this.tasks.get(id))
+            .filter((t) => t !== undefined && t.status === 'pending');
+    }
+    /**
+     * Get recent tasks (last N)
+     */
+    getRecentTasks(limit = 10) {
+        return Array.from(this.tasks.values())
+            .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
+            .slice(0, limit);
+    }
+    /**
+     * Get task by ID
+     */
+    getTask(taskId) {
+        return this.tasks.get(taskId) || null;
+    }
+    /**
+     * Cancel a pending task
+     */
+    cancelTask(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task || task.status !== 'pending')
+            return false;
+        task.status = 'cancelled';
+        this.queue = this.queue.filter(id => id !== taskId);
+        this.onTaskUpdate?.(task);
+        return true;
+    }
+    /**
+     * Create a plan (breaks down a goal into steps)
+     */
+    createPlan(goal, steps) {
+        const plan = {
+            id: `plan_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            goal,
+            steps: steps.map((desc, i) => ({
+                id: `step_${i + 1}`,
+                description: desc,
+                status: 'pending',
+            })),
+            status: 'planning',
+            createdAt: new Date(),
+        };
+        this.plans.set(plan.id, plan);
+        this.onPlanUpdate?.(plan);
+        return plan;
+    }
+    /**
+     * Update a plan step
+     */
+    updatePlanStep(planId, stepId, update) {
+        const plan = this.plans.get(planId);
+        if (!plan)
+            return false;
+        const step = plan.steps.find(s => s.id === stepId);
+        if (!step)
+            return false;
+        Object.assign(step, update);
+        // Update plan status based on steps
+        const allCompleted = plan.steps.every(s => s.status === 'completed');
+        const anyFailed = plan.steps.some(s => s.status === 'failed');
+        const anyInProgress = plan.steps.some(s => s.status === 'in_progress');
+        if (allCompleted) {
+            plan.status = 'completed';
+            plan.completedAt = new Date();
+        }
+        else if (anyFailed) {
+            plan.status = 'failed';
+        }
+        else if (anyInProgress) {
+            plan.status = 'executing';
+        }
+        this.onPlanUpdate?.(plan);
+        return true;
+    }
+    /**
+     * Get current plan
+     */
+    getCurrentPlan() {
+        return Array.from(this.plans.values())
+            .find(p => p.status === 'planning' || p.status === 'executing') || null;
+    }
+    /**
+     * Get all plans
+     */
+    getPlans() {
+        return Array.from(this.plans.values());
+    }
+    /**
+     * Get queue status for display
+     */
+    getStatus() {
+        const pending = this.getPendingTasks();
+        return {
+            isProcessing: this.isProcessing,
+            currentTask: this.getCurrentTask(),
+            pendingCount: pending.length,
+            queuePreview: pending.slice(0, 5).map(t => t.content.length > 50 ? t.content.slice(0, 50) + '...' : t.content),
+        };
+    }
+    /**
+     * Format tasks as readable todo list (for LLM context)
+     */
+    formatAsTodoList() {
+        const current = this.getCurrentTask();
+        const pending = this.getPendingTasks();
+        const recent = this.getRecentTasks(5).filter(t => t.status === 'completed' || t.status === 'failed');
+        const lines = ['## My Task Queue'];
+        if (current) {
+            lines.push('', '### Currently Working On:');
+            lines.push(`- [→] ${current.content}`);
+        }
+        if (pending.length > 0) {
+            lines.push('', '### Pending:');
+            for (const task of pending.slice(0, 10)) {
+                const priority = task.priority !== 'normal' ? ` [${task.priority}]` : '';
+                lines.push(`- [ ] ${task.content}${priority}`);
+            }
+            if (pending.length > 10) {
+                lines.push(`- ... and ${pending.length - 10} more`);
+            }
+        }
+        if (recent.length > 0) {
+            lines.push('', '### Recently Completed:');
+            for (const task of recent) {
+                const icon = task.status === 'completed' ? '✓' : '✗';
+                lines.push(`- [${icon}] ${task.content}`);
+            }
+        }
+        return lines.join('\n');
+    }
+}

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * from './config.js';
 export * from './api.js';
 export * from './agent.js';
 export * from './websocket.js';
+export * from './core/task-queue.js';

package/dist/index.js

@@ -2,3 +2,4 @@ export * from './config.js';
 export * from './api.js';
 export * from './agent.js';
 export * from './websocket.js';
+export * from './core/task-queue.js';

package/dist/orchestrator.d.ts

@@ -5,6 +5,7 @@
  * It does NOT do the work itself. Claude Code CLI workers do the work.
  */
 import type { MessageParam } from '@anthropic-ai/sdk/resources/messages';
+import { LiaTask, LiaPlan } from './core/task-queue.js';
 export type MessageSender = (message: string) => Promise<void>;
 export interface WorkerStatus {
     id: string;
@@ -15,6 +16,7 @@ export interface WorkerStatus {
     estimated: number;
 }
 export type WorkerStatusCallback = (workers: WorkerStatus[]) => void;
+export type WorkerLogCallback = (workerId: string, line: string, stream: 'stdout' | 'stderr') => void;
 export interface WorkerAsset {
     path: string;
     name: string;
@@ -33,17 +35,28 @@ export interface GalleryWorker {
     assets: WorkerAsset[];
 }
 export type GalleryCallback = (workers: GalleryWorker[]) => void;
+export type InstanceMode = 'personal' | 'team';
 export declare class MasterOrchestrator {
     private client;
     private model;
     private maxTokens;
     private memory;
+    private contextGraph;
+    private orgMemory?;
+    private orgContextGraph?;
+    private orgId?;
+    private orgRole?;
+    private instanceMode;
+    private userOrgMemories;
+    private userOrgContextGraphs;
     private scheduler;
     private indexer;
     private jobs;
     private jobCounter;
     private workerStatusCallback;
+    private workerLogCallback;
     private workerStatusInterval;
+    private attachmentContext;
     private galleryCallback;
     private userId;
     private workspaceDir;
@@ -52,15 +65,23 @@ export declare class MasterOrchestrator {
     private bashTool;
     private webTools;
     private workerTools;
+    private calendarTools;
     private sharedState;
     private verboseMode;
+    private taskQueue;
+    private taskUpdateCallback?;
+    private planUpdateCallback?;
     constructor(options: {
         apiKey: string;
         userId: string;
+        orgId?: string;
+        orgRole?: 'owner' | 'member';
         workspaceDir?: string;
         model?: string;
         maxTokens?: number;
         voyageApiKey?: string;
+        instanceMode?: InstanceMode;
+        userOrgIds?: string[];
     });
     /**
      * Initialize the orchestrator - indexes filesystem on first call
@@ -70,10 +91,60 @@ export declare class MasterOrchestrator {
      * Set callback for worker status updates (for UI progress bars)
      */
     setWorkerStatusCallback(callback: WorkerStatusCallback | null): void;
+    /**
+     * Set callback for worker log streaming
+     */
+    setWorkerLogCallback(callback: WorkerLogCallback | null): void;
     /**
      * Set callback for gallery updates (worker assets for UI gallery view)
      */
     setGalleryCallback(callback: GalleryCallback | null): void;
+    /**
+     * Set callback for task queue updates (for real-time UI updates)
+     */
+    setTaskUpdateCallback(callback: ((task: LiaTask) => void) | null): void;
+    /**
+     * Set callback for plan updates (for real-time UI updates)
+     */
+    setPlanUpdateCallback(callback: ((plan: LiaPlan) => void) | null): void;
+    /**
+     * Queue a message for async processing (non-blocking)
+     * Returns immediately with task ID - use callbacks or getTaskQueueStatus for results
+     */
+    queueMessage(message: string, options?: {
+        priority?: 'urgent' | 'high' | 'normal' | 'low';
+        apiKey?: string;
+        messageId?: string;
+    }): LiaTask;
+    /**
+     * Process a task from the queue (called by LiaTaskQueue)
+     */
+    private processQueuedTask;
+    /**
+     * Get task queue status (for UI)
+     */
+    getTaskQueueStatus(): {
+        isProcessing: boolean;
+        currentTask: LiaTask | null;
+        pendingCount: number;
+        queuePreview: string[];
+    };
+    /**
+     * Get pending tasks
+     */
+    getPendingTasks(): LiaTask[];
+    /**
+     * Get task by ID
+     */
+    getTask(taskId: string): LiaTask | null;
+    /**
+     * Cancel a pending task
+     */
+    cancelTask(taskId: string): boolean;
+    /**
+     * Get Lia's internal todo list formatted for context
+     */
+    getTaskQueueContext(): string;
     /**
      * Get gallery workers with their assets
      */
@@ -102,6 +173,8 @@ export declare class MasterOrchestrator {
      * Handle slash commands
      */
     private handleSlashCommand;
+    private extractAttachmentContext;
+    private withAttachments;
     /**
      * Check if verbose mode is enabled
      */
@@ -111,14 +184,31 @@ export declare class MasterOrchestrator {
      * @param apiKey Optional per-request API key (overrides default)
      */
     processMessage(message: string, conversationHistory?: MessageParam[], sendMessage?: MessageSender, apiKey?: string): Promise<string>;
+    private tryHandleCalendarTodo;
+    private extractTodoItems;
+    private extractCalendarEvents;
+    private parseCalendarEvent;
+    private parseExplicitDateTimeEvent;
+    private to24h;
+    private nextOccurrence;
+    private toDateKey;
     /**
      * Get relevant memory context for a message
+     * Routes based on instanceMode:
+     * - personal: search personal memories + all team memories
+     * - team: search ONLY team memory (never personal - team Lia is isolated)
      */
     private getMemoryContext;
     /**
      * Auto-remember important information from conversations
+     * Routes based on instanceMode:
+     * - personal: write to personal memory
+     * - team: write to team memory
      */
     private autoRemember;
+    private autoCaptureContext;
+    private normalizeEntityName;
+    private isIgnoredEntity;
     /**
      * Run the agentic loop
      * @param apiKey Optional per-request API key (creates temporary client)
@@ -162,10 +252,16 @@ export declare class MasterOrchestrator {
     private extractWorkerMemories;
     /**
      * Execute remember tool
+     * Routes writes based on instanceMode:
+     * - personal: write to personal memory only
+     * - team: write to team memory only
      */
     private executeRemember;
     /**
      * Execute search memory tool
+     * Routes searches based on instanceMode:
+     * - personal: search personal + all team memories
+     * - team: search team memory only (never personal)
      */
     private executeSearchMemory;
     /**
@@ -192,6 +288,18 @@ export declare class MasterOrchestrator {
      * Stop a running server on a port
      */
     private executeStopServer;
+    /**
+     * Create a plan with steps (Lia's internal planning)
+     */
+    private executeLiaPlan;
+    /**
+     * Add a task to Lia's internal queue
+     */
+    private executeLiaAddTask;
+    /**
+     * Get Lia's task queue status
+     */
+    private executeLiaGetQueue;
     /**
      * Format tool preview for user
      */