@siftd/connect-agent 0.2.37 → 0.2.39

package/dist/core/context-graph.js

@@ -0,0 +1,247 @@
+const ENTITY_PREFIX = 'CTX_ENTITY ';
+const RELATION_PREFIX = 'CTX_REL ';
+const DEFAULT_SCOPE = 'user';
+const ENTITY_KINDS = [
+    'person',
+    'team',
+    'project',
+    'org',
+    'role',
+    'tool',
+    'document',
+    'task',
+    'system',
+    'topic'
+];
+const RELATION_KINDS = [
+    'member_of',
+    'leads',
+    'works_on',
+    'owns',
+    'depends_on',
+    'blocked_by',
+    'related_to',
+    'uses',
+    'reports_to',
+    'supports',
+    'delivers_to',
+    'requested_by',
+    'scheduled_for'
+];
+function slugify(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/(^-|-$)/g, '');
+}
+function buildEntityKey(kind, name) {
+    return `${kind}:${slugify(name)}`;
+}
+function normalizeTags(tags) {
+    return Array.from(new Set(tags.filter(Boolean)));
+}
+export class ContextGraph {
+    memory;
+    scope;
+    constructor(memory, options) {
+        this.memory = memory;
+        this.scope = options?.scope || DEFAULT_SCOPE;
+    }
+    async upsertEntity(input) {
+        const name = input.name.trim();
+        const kind = input.kind;
+        const key = input.key ? this.normalizeKey(input.key, kind, name) : buildEntityKey(kind, name);
+        const existing = await this.findEntityByKey(key);
+        if (existing) {
+            const parsed = parseEntity(existing.content);
+            if (parsed)
+                return parsed;
+        }
+        const payload = {
+            key,
+            kind,
+            name,
+            description: input.description?.trim() || undefined,
+            attributes: input.attributes,
+            source: input.source || 'context-graph',
+            updatedAt: new Date().toISOString()
+        };
+        const tags = normalizeTags([
+            'ctx:entity',
+            `ctx:kind:${kind}`,
+            `ctx:key:${key}`,
+            `ctx:name:${slugify(name)}`,
+            `ctx:scope:${this.scope}`,
+            ...(input.tags || [])
+        ]);
+        await this.memory.remember(`${ENTITY_PREFIX}${JSON.stringify(payload)}`, {
+            type: 'semantic',
+            source: payload.source,
+            importance: input.importance ?? 0.7,
+            tags
+        });
+        return payload;
+    }
+    async linkEntities(input) {
+        const fromEntity = await this.resolveEntity(input.from, input.fromKind);
+        const toEntity = await this.resolveEntity(input.to, input.toKind);
+        const relationKeyTags = [
+            'ctx:edge',
+            `ctx:rel:${input.type}`,
+            `ctx:from:${fromEntity.key}`,
+            `ctx:to:${toEntity.key}`,
+            `ctx:scope:${this.scope}`
+        ];
+        const existing = await this.findByTags(relationKeyTags, 1);
+        if (existing.length > 0) {
+            const parsed = parseRelation(existing[0].content);
+            if (parsed)
+                return parsed;
+        }
+        const payload = {
+            from: fromEntity.key,
+            to: toEntity.key,
+            type: input.type,
+            description: input.description?.trim() || undefined,
+            source: input.source || 'context-graph',
+            updatedAt: new Date().toISOString()
+        };
+        await this.memory.remember(`${RELATION_PREFIX}${JSON.stringify(payload)}`, {
+            type: 'semantic',
+            source: payload.source,
+            importance: 0.6,
+            tags: relationKeyTags
+        });
+        return payload;
+    }
+    async searchEntities(query, options) {
+        const limit = options?.limit ?? 6;
+        const results = await this.memory.search(query, { limit: limit * 2 });
+        const entities = results
+            .map(result => parseEntity(result.content))
+            .filter((entity) => !!entity)
+            .filter(entity => !options?.kind || entity.kind === options.kind);
+        const deduped = new Map();
+        for (const entity of entities) {
+            if (!deduped.has(entity.key)) {
+                deduped.set(entity.key, entity);
+            }
+        }
+        return Array.from(deduped.values()).slice(0, limit);
+    }
+    async getRelationsForEntity(key, options) {
+        const limit = options?.limit ?? 6;
+        const outgoing = await this.findByTags(['ctx:edge', `ctx:from:${key}`], limit);
+        const incoming = await this.findByTags(['ctx:edge', `ctx:to:${key}`], limit);
+        const relations = [...outgoing, ...incoming]
+            .map(result => parseRelation(result.content))
+            .filter((rel) => !!rel);
+        const deduped = new Map();
+        for (const relation of relations) {
+            const relationKey = `${relation.from}|${relation.type}|${relation.to}`;
+            if (!deduped.has(relationKey)) {
+                deduped.set(relationKey, relation);
+            }
+        }
+        return Array.from(deduped.values()).slice(0, limit);
+    }
+    async getContextSummary(query, options) {
+        const entities = await this.searchEntities(query, { limit: options?.limit ?? 4 });
+        if (entities.length === 0)
+            return null;
+        const lines = [];
+        for (const entity of entities) {
+            const relations = await this.getRelationsForEntity(entity.key, { limit: 3 });
+            const relSummary = relations.map(relation => {
+                const other = relation.from === entity.key ? relation.to : relation.from;
+                return `${relation.type} -> ${other}`;
+            });
+            const desc = entity.description ? ` - ${entity.description}` : '';
+            const relText = relSummary.length > 0 ? ` (${relSummary.join('; ')})` : '';
+            lines.push(`[${entity.kind}] ${entity.name}${desc}${relText}`);
+        }
+        return lines.join('\n');
+    }
+    normalizeKey(value, kind, fallbackName) {
+        const trimmed = value.trim();
+        const match = trimmed.split(':');
+        if (match.length >= 2 && ENTITY_KINDS.includes(match[0])) {
+            return `${match[0]}:${slugify(match.slice(1).join(':'))}`;
+        }
+        if (trimmed.length > 0 && trimmed.includes(':')) {
+            return trimmed;
+        }
+        return buildEntityKey(kind, trimmed || fallbackName);
+    }
+    async resolveEntity(value, kind) {
+        const name = value.trim();
+        const inferredKind = kind || this.inferKind(name);
+        const key = this.normalizeKey(name, inferredKind, name);
+        const existing = await this.findEntityByKey(key);
+        if (existing) {
+            const parsed = parseEntity(existing.content);
+            if (parsed)
+                return parsed;
+        }
+        return this.upsertEntity({ kind: inferredKind, name });
+    }
+    inferKind(value) {
+        const lower = value.toLowerCase();
+        if (lower.includes('team'))
+            return 'team';
+        if (lower.includes('project'))
+            return 'project';
+        if (lower.includes('org') || lower.includes('company'))
+            return 'org';
+        return 'topic';
+    }
+    async findEntityByKey(key) {
+        const results = await this.findByTags(['ctx:entity', `ctx:key:${key}`], 2);
+        if (results.length === 0)
+            return null;
+        return this.pickMostRecent(results);
+    }
+    async findByTags(tags, limit) {
+        if (this.memory.findByTags) {
+            return this.memory.findByTags(tags, { limit });
+        }
+        const query = tags.join(' ');
+        const results = await this.memory.search(query, { limit: limit * 2 });
+        return results.filter(result => tags.every(tag => result.tags.includes(tag))).slice(0, limit);
+    }
+    pickMostRecent(records) {
+        return records.sort((a, b) => b.timestamp.localeCompare(a.timestamp))[0];
+    }
+}
+function parseEntity(content) {
+    if (!content.startsWith(ENTITY_PREFIX))
+        return null;
+    const raw = content.slice(ENTITY_PREFIX.length).trim();
+    try {
+        const data = JSON.parse(raw);
+        if (!data.key || !data.kind || !data.name)
+            return null;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+function parseRelation(content) {
+    if (!content.startsWith(RELATION_PREFIX))
+        return null;
+    const raw = content.slice(RELATION_PREFIX.length).trim();
+    try {
+        const data = JSON.parse(raw);
+        if (!data.from || !data.to || !data.type)
+            return null;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+export const ContextGraphKinds = {
+    entities: ENTITY_KINDS,
+    relations: RELATION_KINDS
+};

package/dist/core/file-tracker.js

@@ -23,7 +23,7 @@ const TEXT_EXTENSIONS = new Set([
 // Directories to skip
 const SKIP_DIRS = new Set([
     'node_modules', '.git', '.next', 'dist', 'build', '__pycache__',
-    '.cache', 'coverage', '.nyc_output', 'vendor', 'target'
+    '.cache', 'coverage', '.nyc_output', 'vendor', 'target', '.lia'
 ]);
 // Max files to track (performance limit)
 const MAX_FILES = 500;
@@ -165,6 +165,8 @@ function getFileType(ext) {
  * Check if a file is worth tracking
  */
 function isInterestingFile(name, ext) {
+    if (name.includes('.asset.json') || name.includes('.preview.json'))
+        return false;
     // Skip hidden files (except some config files)
     if (name.startsWith('.') && !TEXT_EXTENSIONS.has(ext))
         return false;

package/dist/core/hub.js

@@ -4,7 +4,8 @@
  * Manages structured memory files in ~/.connect-hub/
  * Human-readable markdown files that the orchestrator reads/writes.
  */
-import { existsSync, readFileSync, writeFileSync, appendFileSync, mkdirSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, appendFileSync, mkdirSync, chmodSync, chownSync } from 'fs';
+import { execSync } from 'child_process';
 import { join } from 'path';
 import { homedir } from 'os';
 const HUB_DIR = join(homedir(), '.connect-hub');
@@ -15,6 +16,38 @@ const NOTEBOOK_A_DIR = join(LIA_HUB_DIR, 'notebook-a');
 const DRAFTS_DIR = join(NOTEBOOK_A_DIR, 'drafts');
 const SHARED_DIR = join(LIA_HUB_DIR, 'shared');
 const OUTPUTS_DIR = join(SHARED_DIR, 'outputs');
+const LIA_STATE_DIR = join(OUTPUTS_DIR, '.lia');
+let cachedLiaGid = null;
+function getLiaGid() {
+    if (cachedLiaGid !== null)
+        return cachedLiaGid;
+    try {
+        const gidText = execSync('id -g lia', { stdio: ['ignore', 'pipe', 'ignore'] })
+            .toString()
+            .trim();
+        const gid = Number(gidText);
+        cachedLiaGid = Number.isFinite(gid) ? gid : null;
+    }
+    catch {
+        cachedLiaGid = null;
+    }
+    return cachedLiaGid;
+}
+function ensureDirPermissions(dir) {
+    if (process.getuid?.() !== 0)
+        return;
+    const liaGid = getLiaGid();
+    if (liaGid === null)
+        return;
+    try {
+        chownSync(dir, 0, liaGid);
+        chmodSync(dir, 0o775);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[HUB] Permission fix failed for ${dir}: ${message}`);
+    }
+}
 /**
  * Ensure Lia-Hub directory structure exists
  * Called on agent start to create the orchestrator's workspace
@@ -26,6 +59,7 @@ export function ensureLiaHub() {
         DRAFTS_DIR,
         SHARED_DIR,
         OUTPUTS_DIR,
+        LIA_STATE_DIR,
         join(LIA_HUB_DIR, 'projects')
     ];
     for (const dir of dirs) {
@@ -33,6 +67,7 @@ export function ensureLiaHub() {
             mkdirSync(dir, { recursive: true });
             console.log(`[HUB] Created: ${dir}`);
         }
+        ensureDirPermissions(dir);
     }
     // Create template files if they don't exist
     const agentsFile = join(LIA_HUB_DIR, 'AGENTS.md');

package/dist/core/memory-advanced.d.ts

@@ -53,6 +53,11 @@ export declare class AdvancedMemoryStore {
         includeAssociations?: boolean;
     }): Promise<Memory[]>;
     private textSearch;
+    findByTags(tags: string[], options?: {
+        limit?: number;
+        type?: MemoryType;
+        minImportance?: number;
+    }): Promise<Memory[]>;
     getById(id: string): Memory | null;
     getByType(type: MemoryType, limit?: number): Memory[];
     recall(id: string): Memory | null;

package/dist/core/memory-advanced.js

@@ -242,6 +242,33 @@ export class AdvancedMemoryStore {
         const rows = stmt.all(...params, limit);
         return rows.map(row => this.rowToMemory(row));
     }
+    async findByTags(tags, options = {}) {
+        if (tags.length === 0)
+            return [];
+        const limit = options.limit || 20;
+        const conditions = ['1=1'];
+        const params = [];
+        if (options.type) {
+            conditions.push('type = ?');
+            params.push(options.type);
+        }
+        if (options.minImportance) {
+            conditions.push('importance >= ?');
+            params.push(options.minImportance);
+        }
+        for (const tag of tags) {
+            conditions.push('tags LIKE ?');
+            params.push(`%"${tag}"%`);
+        }
+        const stmt = this.db.prepare(`
+      SELECT * FROM memories
+      WHERE ${conditions.join(' AND ')}
+      ORDER BY lastAccessed DESC
+      LIMIT ?
+    `);
+        const rows = stmt.all(...params, limit);
+        return rows.map(row => this.rowToMemory(row));
+    }
     getById(id) {
         const stmt = this.db.prepare('SELECT * FROM memories WHERE id = ?');
         const row = stmt.get(id);

package/dist/core/memory-postgres.d.ts

@@ -58,10 +58,19 @@ export declare class PostgresMemoryStore {
         limit?: number;
         minImportance?: number;
     }): Promise<Memory[]>;
+    /**
+     * Find memories that contain all provided tags
+     */
+    findByTags(tags: string[], options?: {
+        type?: MemoryType;
+        limit?: number;
+        minImportance?: number;
+    }): Promise<Memory[]>;
     /**
      * Get memory by ID
      */
     get(id: string): Promise<Memory | null>;
+    getById(id: string): Promise<Memory | null>;
     /**
      * Delete a memory
      */

package/dist/core/memory-postgres.js

@@ -197,6 +197,51 @@ export class PostgresMemoryStore {
             hasEmbedding: true
         }));
     }
+    /**
+     * Find memories that contain all provided tags
+     */
+    async findByTags(tags, options) {
+        await this.initialize();
+        if (tags.length === 0)
+            return [];
+        const limit = options?.limit || 20;
+        const minImportance = options?.minImportance || 0;
+        const params = [
+            this.userId,
+            tags,
+            minImportance
+        ];
+        let sql = `
+      SELECT id, type, content, summary, source, timestamp, last_accessed,
+             importance, access_count, decay_rate, associations, tags
+      FROM memories
+      WHERE user_id = $1
+        AND tags @> $2::text[]
+        AND importance >= $3
+    `;
+        if (options?.type) {
+            sql += ` AND type = $${params.length + 1}`;
+            params.push(options.type);
+        }
+        sql += ` ORDER BY last_accessed DESC LIMIT $${params.length + 1}`;
+        params.push(limit);
+        const result = await this.pool.query(sql, params);
+        return result.rows.map(row => ({
+            id: row.id,
+            type: row.type,
+            content: row.content,
+            summary: row.summary,
+            source: row.source,
+            timestamp: row.timestamp.toISOString(),
+            lastAccessed: row.last_accessed.toISOString(),
+            importance: row.importance,
+            accessCount: row.access_count,
+            decayRate: row.decay_rate,
+            associations: row.associations || [],
+            tags: row.tags || [],
+            hasEmbedding: true
+        }));
+    }
     /**
      * Get memory by ID
      */
@@ -224,6 +269,9 @@ export class PostgresMemoryStore {
             hasEmbedding: true
         };
     }
+    async getById(id) {
+        return this.get(id);
+    }
     /**
      * Delete a memory
      */

package/dist/core/preview-worker.js

@@ -23,6 +23,7 @@ import { getSharedOutputPath } from './hub.js';
 const IGNORE_PATTERNS = [
     '**/*.asset.json',
     '**/*.preview.json',
+    '**/.lia/**',
     '**/.thumbs/**',
     '**/thumbs/**',
     '**/*.tmp',
@@ -140,6 +141,8 @@ export class PreviewWorker {
         // Skip if file no longer exists
         if (!existsSync(filePath))
             return;
+        if (filePath.includes('.asset.json') || filePath.includes('.preview.json'))
+            return;
         const startTime = Date.now();
         // Check for existing manifest
         let manifest = readAssetManifest(filePath);

package/dist/core/task-queue.d.ts

@@ -0,0 +1,125 @@
+/**
+ * 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.
+ */
+export type TaskPriority = 'urgent' | 'high' | 'normal' | 'low';
+export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
+export interface LiaTask {
+    id: string;
+    type: 'user_message' | 'follow_up' | 'scheduled' | 'background';
+    content: string;
+    priority: TaskPriority;
+    status: TaskStatus;
+    createdAt: Date;
+    startedAt?: Date;
+    completedAt?: Date;
+    result?: string;
+    error?: string;
+    metadata?: {
+        userId?: string;
+        messageId?: string;
+        parentTaskId?: string;
+        apiKey?: string;
+        context?: 'personal' | 'team';
+        orgId?: string;
+    };
+}
+export interface LiaPlan {
+    id: string;
+    goal: string;
+    steps: LiaPlanStep[];
+    status: 'planning' | 'executing' | 'completed' | 'failed';
+    createdAt: Date;
+    completedAt?: Date;
+}
+export interface LiaPlanStep {
+    id: string;
+    description: string;
+    status: TaskStatus;
+    taskId?: string;
+    notes?: string;
+}
+export type TaskQueueCallback = (task: LiaTask) => void;
+export type PlanCallback = (plan: LiaPlan) => void;
+/**
+ * Lia's task queue - manages her internal todo list
+ */
+export declare class LiaTaskQueue {
+    private tasks;
+    private plans;
+    private queue;
+    private currentTask;
+    private isProcessing;
+    private onTaskUpdate?;
+    private onPlanUpdate?;
+    private processTask?;
+    constructor(options?: {
+        onTaskUpdate?: TaskQueueCallback;
+        onPlanUpdate?: PlanCallback;
+        processTask?: (task: LiaTask) => Promise<string>;
+    });
+    /**
+     * Add a new task to the queue
+     */
+    addTask(task: Omit<LiaTask, 'id' | 'status' | 'createdAt'>): LiaTask;
+    /**
+     * Insert task ID into queue based on priority
+     */
+    private insertByPriority;
+    /**
+     * Start processing the queue
+     */
+    startProcessing(): Promise<void>;
+    /**
+     * Get the current task being processed
+     */
+    getCurrentTask(): LiaTask | null;
+    /**
+     * Get all pending tasks
+     */
+    getPendingTasks(): LiaTask[];
+    /**
+     * Get recent tasks (last N)
+     */
+    getRecentTasks(limit?: number): LiaTask[];
+    /**
+     * Get task by ID
+     */
+    getTask(taskId: string): LiaTask | null;
+    /**
+     * Cancel a pending task
+     */
+    cancelTask(taskId: string): boolean;
+    /**
+     * Create a plan (breaks down a goal into steps)
+     */
+    createPlan(goal: string, steps: string[]): LiaPlan;
+    /**
+     * Update a plan step
+     */
+    updatePlanStep(planId: string, stepId: string, update: Partial<LiaPlanStep>): boolean;
+    /**
+     * Get current plan
+     */
+    getCurrentPlan(): LiaPlan | null;
+    /**
+     * Get all plans
+     */
+    getPlans(): LiaPlan[];
+    /**
+     * Get queue status for display
+     */
+    getStatus(): {
+        isProcessing: boolean;
+        currentTask: LiaTask | null;
+        pendingCount: number;
+        queuePreview: string[];
+    };
+    /**
+     * Format tasks as readable todo list (for LLM context)
+     */
+    formatAsTodoList(): string;
+}