@mnemoai/core 1.1.0 → 1.1.1

package/src/scopes.ts

@@ -1,375 +0,0 @@
-// SPDX-License-Identifier: MIT
-/**
- * Multi-Scope Access Control System
- * Manages memory isolation and access permissions
- */
-
-// ============================================================================
-// Types & Configuration
-// ============================================================================
-
-export interface ScopeDefinition {
-  description: string;
-  metadata?: Record<string, unknown>;
-}
-
-export interface ScopeConfig {
-  default: string;
-  definitions: Record<string, ScopeDefinition>;
-  agentAccess: Record<string, string[]>;
-}
-
-export interface ScopeManager {
-  getAccessibleScopes(agentId?: string): string[];
-  getDefaultScope(agentId?: string): string;
-  isAccessible(scope: string, agentId?: string): boolean;
-  validateScope(scope: string): boolean;
-  getAllScopes(): string[];
-  getScopeDefinition(scope: string): ScopeDefinition | undefined;
-}
-
-// ============================================================================
-// Default Configuration
-// ============================================================================
-
-export const DEFAULT_SCOPE_CONFIG: ScopeConfig = {
-  default: "global",
-  definitions: {
-    global: {
-      description: "Shared knowledge across all agents",
-    },
-  },
-  agentAccess: {},
-};
-
-// ============================================================================
-// Built-in Scope Patterns
-// ============================================================================
-
-const SCOPE_PATTERNS = {
-  GLOBAL: "global",
-  AGENT: (agentId: string) => `agent:${agentId}`,
-  CUSTOM: (name: string) => `custom:${name}`,
-  PROJECT: (projectId: string) => `project:${projectId}`,
-  USER: (userId: string) => `user:${userId}`,
-};
-
-// ============================================================================
-// Scope Manager Implementation
-// ============================================================================
-
-export class MemoryScopeManager implements ScopeManager {
-  private config: ScopeConfig;
-
-  constructor(config: Partial<ScopeConfig> = {}) {
-    this.config = {
-      default: config.default || DEFAULT_SCOPE_CONFIG.default,
-      definitions: {
-        ...DEFAULT_SCOPE_CONFIG.definitions,
-        ...config.definitions,
-      },
-      agentAccess: {
-        ...DEFAULT_SCOPE_CONFIG.agentAccess,
-        ...config.agentAccess,
-      },
-    };
-
-    // Ensure global scope always exists
-    if (!this.config.definitions.global) {
-      this.config.definitions.global = {
-        description: "Shared knowledge across all agents",
-      };
-    }
-
-    this.validateConfiguration();
-  }
-
-  private validateConfiguration(): void {
-    // Validate default scope exists in definitions
-    if (!this.config.definitions[this.config.default]) {
-      throw new Error(`Default scope '${this.config.default}' not found in definitions`);
-    }
-
-    // Validate agent access scopes exist in definitions
-    for (const [agentId, scopes] of Object.entries(this.config.agentAccess)) {
-      for (const scope of scopes) {
-        if (!this.config.definitions[scope] && !this.isBuiltInScope(scope)) {
-          console.warn(`Agent '${agentId}' has access to undefined scope '${scope}'`);
-        }
-      }
-    }
-  }
-
-  private isBuiltInScope(scope: string): boolean {
-    return (
-      scope === "global" ||
-      scope.startsWith("agent:") ||
-      scope.startsWith("custom:") ||
-      scope.startsWith("project:") ||
-      scope.startsWith("user:")
-    );
-  }
-
-  getAccessibleScopes(agentId?: string): string[] {
-    if (!agentId) {
-      // No agent specified, return all scopes
-      return this.getAllScopes();
-    }
-
-    // Check explicit agent access configuration
-    const explicitAccess = this.config.agentAccess[agentId];
-    if (explicitAccess) {
-      return explicitAccess;
-    }
-
-    // Default access: global + agent-specific scope
-    const defaultScopes = ["global"];
-    const agentScope = SCOPE_PATTERNS.AGENT(agentId);
-
-    // Only include agent scope if it already exists — don't mutate config as a side effect
-    if (this.config.definitions[agentScope] || this.isBuiltInScope(agentScope)) {
-      defaultScopes.push(agentScope);
-    }
-
-    return defaultScopes;
-  }
-
-  getDefaultScope(agentId?: string): string {
-    if (!agentId) {
-      return this.config.default;
-    }
-
-    // For agents, default to their private scope if they have access to it
-    const agentScope = SCOPE_PATTERNS.AGENT(agentId);
-    const accessibleScopes = this.getAccessibleScopes(agentId);
-
-    if (accessibleScopes.includes(agentScope)) {
-      return agentScope;
-    }
-
-    return this.config.default;
-  }
-
-  isAccessible(scope: string, agentId?: string): boolean {
-    if (!agentId) {
-      // No agent specified, allow access to all valid scopes
-      return this.validateScope(scope);
-    }
-
-    const accessibleScopes = this.getAccessibleScopes(agentId);
-    return accessibleScopes.includes(scope);
-  }
-
-  validateScope(scope: string): boolean {
-    if (!scope || typeof scope !== "string" || scope.trim().length === 0) {
-      return false;
-    }
-
-    const trimmedScope = scope.trim();
-
-    // Check if scope is defined or is a built-in pattern
-    return (
-      this.config.definitions[trimmedScope] !== undefined ||
-      this.isBuiltInScope(trimmedScope)
-    );
-  }
-
-  getAllScopes(): string[] {
-    return Object.keys(this.config.definitions);
-  }
-
-  getScopeDefinition(scope: string): ScopeDefinition | undefined {
-    return this.config.definitions[scope];
-  }
-
-  // Management methods
-
-  addScopeDefinition(scope: string, definition: ScopeDefinition): void {
-    if (!this.validateScopeFormat(scope)) {
-      throw new Error(`Invalid scope format: ${scope}`);
-    }
-
-    this.config.definitions[scope] = definition;
-  }
-
-  removeScopeDefinition(scope: string): boolean {
-    if (scope === "global") {
-      throw new Error("Cannot remove global scope");
-    }
-
-    if (!this.config.definitions[scope]) {
-      return false;
-    }
-
-    delete this.config.definitions[scope];
-
-    // Clean up agent access references
-    for (const [agentId, scopes] of Object.entries(this.config.agentAccess)) {
-      const filtered = scopes.filter(s => s !== scope);
-      if (filtered.length !== scopes.length) {
-        this.config.agentAccess[agentId] = filtered;
-      }
-    }
-
-    return true;
-  }
-
-  setAgentAccess(agentId: string, scopes: string[]): void {
-    if (!agentId || typeof agentId !== "string") {
-      throw new Error("Invalid agent ID");
-    }
-
-    // Validate all scopes
-    for (const scope of scopes) {
-      if (!this.validateScope(scope)) {
-        throw new Error(`Invalid scope: ${scope}`);
-      }
-    }
-
-    this.config.agentAccess[agentId] = [...scopes];
-  }
-
-  removeAgentAccess(agentId: string): boolean {
-    if (!this.config.agentAccess[agentId]) {
-      return false;
-    }
-
-    delete this.config.agentAccess[agentId];
-    return true;
-  }
-
-  private validateScopeFormat(scope: string): boolean {
-    if (!scope || typeof scope !== "string") {
-      return false;
-    }
-
-    const trimmed = scope.trim();
-
-    // Basic format validation
-    if (trimmed.length === 0 || trimmed.length > 100) {
-      return false;
-    }
-
-    // Allow alphanumeric, hyphens, underscores, colons, and dots
-    const validFormat = /^[a-zA-Z0-9._:-]+$/.test(trimmed);
-    return validFormat;
-  }
-
-  // Export/Import configuration
-
-  exportConfig(): ScopeConfig {
-    return JSON.parse(JSON.stringify(this.config));
-  }
-
-  importConfig(config: Partial<ScopeConfig>): void {
-    this.config = {
-      default: config.default || this.config.default,
-      definitions: {
-        ...this.config.definitions,
-        ...config.definitions,
-      },
-      agentAccess: {
-        ...this.config.agentAccess,
-        ...config.agentAccess,
-      },
-    };
-
-    this.validateConfiguration();
-  }
-
-  // Statistics
-
-  getStats(): {
-    totalScopes: number;
-    agentsWithCustomAccess: number;
-    scopesByType: Record<string, number>;
-  } {
-    const scopes = this.getAllScopes();
-    const scopesByType: Record<string, number> = {
-      global: 0,
-      agent: 0,
-      custom: 0,
-      project: 0,
-      user: 0,
-      other: 0,
-    };
-
-    for (const scope of scopes) {
-      if (scope === "global") {
-        scopesByType.global++;
-      } else if (scope.startsWith("agent:")) {
-        scopesByType.agent++;
-      } else if (scope.startsWith("custom:")) {
-        scopesByType.custom++;
-      } else if (scope.startsWith("project:")) {
-        scopesByType.project++;
-      } else if (scope.startsWith("user:")) {
-        scopesByType.user++;
-      } else {
-        scopesByType.other++;
-      }
-    }
-
-    return {
-      totalScopes: scopes.length,
-      agentsWithCustomAccess: Object.keys(this.config.agentAccess).length,
-      scopesByType,
-    };
-  }
-}
-
-// ============================================================================
-// Factory Functions
-// ============================================================================
-
-export function createScopeManager(config?: Partial<ScopeConfig>): MemoryScopeManager {
-  return new MemoryScopeManager(config);
-}
-
-export function createAgentScope(agentId: string): string {
-  return SCOPE_PATTERNS.AGENT(agentId);
-}
-
-export function createCustomScope(name: string): string {
-  return SCOPE_PATTERNS.CUSTOM(name);
-}
-
-export function createProjectScope(projectId: string): string {
-  return SCOPE_PATTERNS.PROJECT(projectId);
-}
-
-export function createUserScope(userId: string): string {
-  return SCOPE_PATTERNS.USER(userId);
-}
-
-// ============================================================================
-// Utility Functions
-// ============================================================================
-
-export function parseScopeId(scope: string): { type: string; id: string } | null {
-  if (scope === "global") {
-    return { type: "global", id: "" };
-  }
-
-  const colonIndex = scope.indexOf(":");
-  if (colonIndex === -1) {
-    return null;
-  }
-
-  return {
-    type: scope.substring(0, colonIndex),
-    id: scope.substring(colonIndex + 1),
-  };
-}
-
-export function isScopeAccessible(scope: string, allowedScopes: string[]): boolean {
-  return allowedScopes.includes(scope);
-}
-
-export function filterScopesForAgent(scopes: string[], agentId?: string, scopeManager?: ScopeManager): string[] {
-  if (!scopeManager || !agentId) {
-    return scopes;
-  }
-
-  return scopes.filter(scope => scopeManager.isAccessible(scope, agentId));
-}

package/src/semantic-gate.ts

@@ -1,121 +0,0 @@
-// SPDX-License-Identifier: MIT
-/**
- * Semantic Noise Gate
- *
- * Pre-filters memory candidates by checking their embedding similarity against
- * domain-relevant anchor texts. Fragments that are too far from any anchor are
- * rejected as noise before reaching the dedup or store pipeline.
- */
-
-import type { Embedder } from "./embedder.js";
-import { appendFile, mkdir } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join, dirname } from "node:path";
-
-// ============================================================================
-// Anchor Texts
-// ============================================================================
-
-const ANCHOR_TEXTS = [
-  "投资决策 估值分析 持仓管理 尽职调查",
-  "个人偏好 日常习惯 人际关系 生活方式",
-  "技术架构 系统设计 代码实现 工程优化",
-] as const;
-
-// ============================================================================
-// Cosine Similarity
-// ============================================================================
-
-function cosineSimilarity(a: number[], b: number[]): number {
-  if (a.length !== b.length || a.length === 0) return 0;
-  let dot = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  const denom = Math.sqrt(normA) * Math.sqrt(normB);
-  return denom === 0 ? 0 : dot / denom;
-}
-
-// ============================================================================
-// Semantic Gate
-// ============================================================================
-
-const FILTER_LOG_PATH = join(homedir(), ".openclaw", "memory", "store-filtered.log");
-
-export class SemanticGate {
-  private anchorEmbeddings: number[][] | null = null;
-  private initPromise: Promise<void> | null = null;
-  private readonly threshold: number;
-
-  constructor(
-    private readonly embedder: Embedder,
-    threshold = 0.20,
-  ) {
-    this.threshold = threshold;
-  }
-
-  private async ensureInitialized(): Promise<void> {
-    if (this.anchorEmbeddings) return;
-    if (this.initPromise) return this.initPromise;
-
-    this.initPromise = this.computeAnchors().catch((err) => {
-      this.initPromise = null;
-      throw err;
-    });
-    return this.initPromise;
-  }
-
-  private async computeAnchors(): Promise<void> {
-    const embeddings: number[][] = [];
-    for (const text of ANCHOR_TEXTS) {
-      const vec = await this.embedder.embed(text);
-      embeddings.push(vec);
-    }
-    this.anchorEmbeddings = embeddings;
-  }
-
-  /**
-   * Check whether a memory vector passes the semantic gate.
-   * Returns true if the memory is relevant enough to persist.
-   */
-  async shouldPass(vector: number[], text: string): Promise<boolean> {
-    try {
-      await this.ensureInitialized();
-    } catch {
-      // If anchor computation fails, pass everything through
-      return true;
-    }
-
-    if (!this.anchorEmbeddings || this.anchorEmbeddings.length === 0) {
-      return true;
-    }
-
-    let maxSim = 0;
-    for (const anchor of this.anchorEmbeddings) {
-      const sim = cosineSimilarity(vector, anchor);
-      if (sim > maxSim) maxSim = sim;
-    }
-
-    if (maxSim < this.threshold) {
-      // Log filtered content
-      this.logFiltered(text, maxSim).catch(() => {});
-      return false;
-    }
-
-    return true;
-  }
-
-  private async logFiltered(text: string, maxSim: number): Promise<void> {
-    try {
-      await mkdir(dirname(FILTER_LOG_PATH), { recursive: true });
-      const line = `${new Date().toISOString()} maxSim=${maxSim.toFixed(4)} text=${text.slice(0, 200).replace(/\n/g, " ")}\n`;
-      await appendFile(FILTER_LOG_PATH, line, "utf8");
-    } catch {
-      // Non-critical
-    }
-  }
-}