@lov3kaizen/agentsea-memory 0.5.1

package/dist/debug/index.d.cts

@@ -0,0 +1,3 @@
+export { B as Breakpoint, m as DebugTrace, D as Debugger, o as DebuggerEvents, p as ExportFormat, q as ExportResult, f as Exporter, h as HealthIssue, H as HealthReport, r as ImportResult, i as InspectionResult, a as Inspector, M as MemoryStats, n as RetrievalDebugInfo, b as Timeline, j as TimelineEvent, l as TimelineMarker, k as TimelineSegment, e as createDebugger, g as createExporter, c as createInspector, d as createTimeline } from '../index-C7pEiT8L.cjs';
+import '../core.types-lkxKv-bW.cjs';
+import 'eventemitter3';

package/dist/debug/index.d.ts

@@ -0,0 +1,3 @@
+export { B as Breakpoint, m as DebugTrace, D as Debugger, o as DebuggerEvents, p as ExportFormat, q as ExportResult, f as Exporter, h as HealthIssue, H as HealthReport, r as ImportResult, i as InspectionResult, a as Inspector, M as MemoryStats, n as RetrievalDebugInfo, b as Timeline, j as TimelineEvent, l as TimelineMarker, k as TimelineSegment, e as createDebugger, g as createExporter, c as createInspector, d as createTimeline } from '../index-Bczz1Eyk.js';
+import '../core.types-lkxKv-bW.js';
+import 'eventemitter3';

package/dist/debug/index.js

@@ -0,0 +1,20 @@
+import {
+  Debugger,
+  Exporter,
+  Inspector,
+  Timeline,
+  createDebugger,
+  createExporter,
+  createInspector,
+  createTimeline
+} from "../chunk-YI7RPDEV.js";
+export {
+  Debugger,
+  Exporter,
+  Inspector,
+  Timeline,
+  createDebugger,
+  createExporter,
+  createInspector,
+  createTimeline
+};

package/dist/index-7SsAJ4et.d.ts

@@ -0,0 +1,525 @@
+import { EventEmitter } from 'eventemitter3';
+import { c as MemoryEntry, i as MemoryStoreInterface } from './core.types-lkxKv-bW.js';
+
+/**
+ * Sharing Types
+ *
+ * Types for multi-agent shared memory.
+ */
+
+/**
+ * Memory visibility
+ */
+type MemoryVisibility = 'public' | 'team' | 'private';
+/**
+ * Access permission
+ */
+type AccessPermission = 'read' | 'write' | 'delete' | 'admin';
+/**
+ * Sync strategy
+ */
+type SyncStrategy = 'strong' | 'eventual' | 'manual';
+/**
+ * Conflict resolution strategy
+ */
+type ConflictResolution = 'last-write-wins' | 'first-write-wins' | 'merge' | 'manual';
+/**
+ * Shared memory configuration
+ */
+interface SharedMemoryConfig {
+    conflictResolution?: ConflictResolution;
+    syncInterval?: number;
+    enableLocking?: boolean;
+    lockTimeout?: number;
+    maxSharedEntries?: number;
+}
+/**
+ * Sync manager configuration
+ */
+interface SyncManagerConfig {
+    strategy: SyncStrategy;
+    conflictResolution: ConflictResolution;
+    syncInterval?: number;
+    retryAttempts?: number;
+    retryDelay?: number;
+}
+/**
+ * Access control configuration
+ */
+interface AccessControlConfig {
+    roles?: Record<string, AccessPermission[]>;
+    defaultRole?: string;
+    adminUsers?: string[];
+    defaultPermission?: AccessPermission;
+    enableAuditLog?: boolean;
+    strictMode?: boolean;
+    maxRulesPerAgent?: number;
+}
+/**
+ * Namespace configuration
+ */
+interface NamespaceConfig {
+    name: string;
+    description?: string;
+    visibility?: MemoryVisibility;
+    allowedAgents?: string[];
+    maxSize?: number;
+    retentionDays?: number;
+}
+
+/**
+ * SharedMemory
+ *
+ * Shared memory system for multi-agent coordination.
+ */
+
+/**
+ * Shared memory events
+ */
+interface SharedMemoryEvents {
+    write: (agentId: string, key: string, value: unknown) => void;
+    read: (agentId: string, key: string) => void;
+    delete: (agentId: string, key: string) => void;
+    sync: (agentId: string, entries: MemoryEntry[]) => void;
+    conflict: (key: string, agents: string[]) => void;
+}
+/**
+ * Shared value with metadata
+ */
+interface SharedValue<T = unknown> {
+    value: T;
+    writtenBy: string;
+    writtenAt: number;
+    version: number;
+    readers: Set<string>;
+}
+/**
+ * Sync result
+ */
+interface SyncResult {
+    added: number;
+    updated: number;
+    conflicts: number;
+    timestamp: number;
+}
+/**
+ * Shared memory for multi-agent systems
+ */
+declare class SharedMemory extends EventEmitter<SharedMemoryEvents> {
+    private store;
+    private config;
+    private sharedState;
+    private agentStates;
+    private subscriptions;
+    private lockManager;
+    constructor(store: MemoryStoreInterface, config?: SharedMemoryConfig);
+    /**
+     * Set a shared value
+     */
+    set(agentId: string, key: string, value: unknown): Promise<boolean>;
+    /**
+     * Get a shared value
+     */
+    get<T = unknown>(agentId: string, key: string): Promise<T | undefined>;
+    /**
+     * Delete a shared value
+     */
+    delete(agentId: string, key: string): Promise<boolean>;
+    /**
+     * Set agent-specific state (not shared)
+     */
+    setAgentState(agentId: string, key: string, value: unknown): void;
+    /**
+     * Get agent-specific state
+     */
+    getAgentState<T = unknown>(agentId: string, key: string): T | undefined;
+    /**
+     * Get all agent state
+     */
+    getAllAgentState(agentId: string): Map<string, unknown>;
+    /**
+     * Subscribe to changes on a key
+     */
+    subscribe(agentId: string, key: string): void;
+    /**
+     * Unsubscribe from changes
+     */
+    unsubscribe(agentId: string, key: string): void;
+    /**
+     * Acquire a lock on a key
+     */
+    acquireLock(agentId: string, key: string): boolean;
+    /**
+     * Release a lock
+     */
+    releaseLock(agentId: string, key: string): boolean;
+    /**
+     * Check if key is locked
+     */
+    isLocked(key: string): boolean;
+    /**
+     * Check if agent has lock
+     */
+    hasLock(key: string, agentId: string): boolean;
+    /**
+     * Share memories from one agent to shared space
+     */
+    shareMemories(agentId: string, entries: MemoryEntry[]): Promise<SyncResult>;
+    /**
+     * Get shared memories
+     */
+    getSharedMemories(_agentId: string): MemoryEntry[];
+    /**
+     * Sync with store
+     */
+    sync(): Promise<void>;
+    /**
+     * Get all shared keys
+     */
+    getSharedKeys(): string[];
+    /**
+     * Get metadata for a shared value
+     */
+    getMetadata(key: string): Omit<SharedValue, 'value'> | undefined;
+    /**
+     * Resolve conflict between values
+     */
+    private resolveConflict;
+    /**
+     * Notify subscribers of changes
+     */
+    private notifySubscribers;
+    /**
+     * Persist shared value to store
+     */
+    private persistSharedValue;
+    /**
+     * Load shared value from store
+     */
+    private loadSharedValue;
+    /**
+     * Get statistics
+     */
+    getStats(): {
+        sharedEntries: number;
+        agentCount: number;
+        activeLocks: number;
+        totalSubscriptions: number;
+    };
+}
+/**
+ * Create shared memory instance
+ */
+declare function createSharedMemory(store: MemoryStoreInterface, config?: SharedMemoryConfig): SharedMemory;
+
+/**
+ * Namespaces
+ *
+ * Namespace management for memory isolation and organization.
+ */
+
+/**
+ * Namespace metadata
+ */
+interface NamespaceMetadata {
+    name: string;
+    description?: string;
+    owner?: string;
+    createdAt: number;
+    updatedAt: number;
+    entryCount: number;
+    tags?: string[];
+    settings: NamespaceSettings;
+}
+/**
+ * Namespace settings
+ */
+interface NamespaceSettings {
+    maxEntries?: number;
+    ttl?: number;
+    accessLevel: 'public' | 'private' | 'restricted';
+    allowedAgents?: string[];
+    readOnly?: boolean;
+}
+/**
+ * Namespace events
+ */
+interface NamespaceEvents {
+    created: (namespace: NamespaceMetadata) => void;
+    deleted: (name: string) => void;
+    updated: (namespace: NamespaceMetadata) => void;
+    entryAdded: (namespace: string, entry: MemoryEntry) => void;
+    accessDenied: (namespace: string, agentId: string, action: string) => void;
+}
+/**
+ * Namespace manager
+ */
+declare class NamespaceManager extends EventEmitter<NamespaceEvents> {
+    private store;
+    private namespaces;
+    private defaultNamespace;
+    constructor(store: MemoryStoreInterface, _config?: NamespaceConfig);
+    /**
+     * Create a new namespace
+     */
+    createNamespace(name: string, options?: {
+        description?: string;
+        owner?: string;
+        tags?: string[];
+        settings?: Partial<NamespaceSettings>;
+    }): NamespaceMetadata;
+    /**
+     * Delete a namespace
+     */
+    deleteNamespace(name: string, deleteEntries?: boolean): Promise<boolean>;
+    /**
+     * Get namespace metadata
+     */
+    getNamespace(name: string): NamespaceMetadata | undefined;
+    /**
+     * List all namespaces
+     */
+    listNamespaces(): NamespaceMetadata[];
+    /**
+     * Update namespace settings
+     */
+    updateNamespace(name: string, updates: Partial<Omit<NamespaceMetadata, 'name' | 'createdAt'>>): NamespaceMetadata | null;
+    /**
+     * Check if agent can access namespace
+     */
+    canAccess(name: string, agentId: string, action?: 'read' | 'write'): boolean;
+    /**
+     * Add entry to namespace
+     */
+    addEntry(namespace: string, entry: Omit<MemoryEntry, 'metadata'> & {
+        metadata?: Record<string, unknown>;
+    }, agentId: string): Promise<string | null>;
+    /**
+     * Query entries in namespace
+     */
+    queryEntries(namespace: string, agentId: string, options?: {
+        query?: string;
+        limit?: number;
+        types?: string[];
+    }): Promise<MemoryEntry[]>;
+    /**
+     * Delete entry from namespace
+     */
+    deleteEntry(namespace: string, entryId: string, agentId: string): Promise<boolean>;
+    /**
+     * Move entries between namespaces
+     */
+    moveEntries(fromNamespace: string, toNamespace: string, entryIds: string[], agentId: string): Promise<number>;
+    /**
+     * Copy entries between namespaces
+     */
+    copyEntries(fromNamespace: string, toNamespace: string, entryIds: string[], agentId: string): Promise<number>;
+    /**
+     * Grant access to namespace
+     */
+    grantAccess(namespace: string, agentId: string): boolean;
+    /**
+     * Revoke access from namespace
+     */
+    revokeAccess(namespace: string, agentId: string): boolean;
+    /**
+     * Set default namespace
+     */
+    setDefaultNamespace(name: string): boolean;
+    /**
+     * Get default namespace
+     */
+    getDefaultNamespace(): string;
+    /**
+     * Get namespace statistics
+     */
+    getNamespaceStats(name: string): Promise<{
+        entryCount: number;
+        totalSize: number;
+        oldestEntry: number | null;
+        newestEntry: number | null;
+        typeDistribution: Record<string, number>;
+    } | null>;
+}
+/**
+ * Create namespace manager
+ */
+declare function createNamespaceManager(store: MemoryStoreInterface, config?: NamespaceConfig): NamespaceManager;
+
+/**
+ * AccessControl
+ *
+ * Permission and access control for multi-agent memory systems.
+ */
+
+/**
+ * Permission levels
+ */
+type Permission = 'none' | 'read' | 'write' | 'admin';
+/**
+ * Permission rule
+ */
+interface PermissionRule {
+    id: string;
+    agentId: string;
+    resource: string;
+    permission: Permission;
+    conditions?: PermissionCondition[];
+    expiresAt?: number;
+    createdBy: string;
+    createdAt: number;
+}
+/**
+ * Permission condition
+ */
+interface PermissionCondition {
+    type: 'time-range' | 'entry-type' | 'importance' | 'custom';
+    value: unknown;
+}
+/**
+ * Access request
+ */
+interface AccessRequest {
+    agentId: string;
+    resource: string;
+    action: 'read' | 'write' | 'delete' | 'admin';
+    entry?: MemoryEntry;
+}
+/**
+ * Access result
+ */
+interface AccessResult {
+    allowed: boolean;
+    reason?: string;
+    matchedRule?: PermissionRule;
+}
+/**
+ * Access log entry
+ */
+interface AccessLogEntry {
+    timestamp: number;
+    agentId: string;
+    resource: string;
+    action: string;
+    allowed: boolean;
+    reason?: string;
+}
+/**
+ * Access control events
+ */
+interface AccessControlEvents {
+    accessGranted: (request: AccessRequest) => void;
+    accessDenied: (request: AccessRequest, reason: string) => void;
+    ruleAdded: (rule: PermissionRule) => void;
+    ruleRemoved: (ruleId: string) => void;
+}
+/**
+ * Access control manager
+ */
+declare class AccessControl extends EventEmitter<AccessControlEvents> {
+    private config;
+    private rules;
+    private accessLog;
+    private maxLogSize;
+    constructor(config?: AccessControlConfig);
+    /**
+     * Add a permission rule
+     */
+    addRule(rule: PermissionRule): boolean;
+    /**
+     * Remove a permission rule
+     */
+    removeRule(ruleId: string): boolean;
+    /**
+     * Get rule by ID
+     */
+    getRule(ruleId: string): PermissionRule | undefined;
+    /**
+     * Get all rules for an agent
+     */
+    getAgentRules(agentId: string): PermissionRule[];
+    /**
+     * Check if access is allowed
+     */
+    checkAccess(request: AccessRequest): AccessResult;
+    /**
+     * Grant permission to agent
+     */
+    grantPermission(granterId: string, agentId: string, resource: string, permission: Permission, options?: {
+        conditions?: PermissionCondition[];
+        expiresAt?: number;
+    }): PermissionRule;
+    /**
+     * Revoke all permissions for agent on resource
+     */
+    revokePermission(agentId: string, resource: string): number;
+    /**
+     * Check if agent has specific permission
+     */
+    hasPermission(agentId: string, resource: string, action: 'read' | 'write' | 'delete' | 'admin'): boolean;
+    /**
+     * Get access log
+     */
+    getAccessLog(options?: {
+        agentId?: string;
+        resource?: string;
+        startTime?: number;
+        endTime?: number;
+        limit?: number;
+    }): AccessLogEntry[];
+    /**
+     * Clear access log
+     */
+    clearAccessLog(): void;
+    /**
+     * Find applicable rules for request
+     */
+    private findApplicableRules;
+    /**
+     * Sort rules by specificity (most specific first)
+     */
+    private sortRulesBySpecificity;
+    /**
+     * Check conditions
+     */
+    private checkConditions;
+    /**
+     * Convert action to required permission level
+     */
+    private actionToPermissionLevel;
+    /**
+     * Convert permission to level number
+     */
+    private permissionToLevel;
+    /**
+     * Check if permission level is sufficient
+     */
+    private hasPermissionLevel;
+    /**
+     * Log access attempt
+     */
+    private logAccess;
+    /**
+     * Get statistics
+     */
+    getStats(): {
+        totalRules: number;
+        agentCount: number;
+        accessGranted: number;
+        accessDenied: number;
+    };
+    /**
+     * Export rules
+     */
+    exportRules(): PermissionRule[];
+    /**
+     * Import rules
+     */
+    importRules(rules: PermissionRule[]): number;
+}
+/**
+ * Create access control manager
+ */
+declare function createAccessControl(config?: AccessControlConfig): AccessControl;
+
+export { type AccessControlConfig as A, type NamespaceConfig as N, type Permission as P, type SharedMemoryConfig as S, type SyncManagerConfig as a, SharedMemory as b, createSharedMemory as c, NamespaceManager as d, createNamespaceManager as e, AccessControl as f, createAccessControl as g, type SharedMemoryEvents as h, type SharedValue as i, type SyncResult as j, type NamespaceMetadata as k, type NamespaceSettings as l, type NamespaceEvents as m, type PermissionRule as n, type PermissionCondition as o, type AccessRequest as p, type AccessResult as q, type AccessLogEntry as r, type AccessControlEvents as s };