@basicmemory/openclaw-basic-memory 0.2.3 → 0.23.0

package/context-engine/basic-memory-context-engine.ts

@@ -1,25 +1,33 @@
-import { createRequire } from "node:module"
-import { dirname, resolve } from "node:path"
-import { pathToFileURL } from "node:url"
-import type { AgentMessage } from "@mariozechner/pi-agent-core"
 import type {
   AssembleResult,
   BootstrapResult,
   CompactResult,
   ContextEngine,
+  SubagentSpawnPreparation,
 } from "openclaw/plugin-sdk"
+import { delegateCompactionToRuntime } from "openclaw/plugin-sdk/core"
 import type { BmClient } from "../bm-client.ts"
 import type { BasicMemoryConfig } from "../config.ts"
 import { selectCaptureTurn } from "../hooks/capture.ts"
 import { loadRecallState } from "../hooks/recall.ts"
 import { log } from "../logger.ts"
 
-const require = createRequire(import.meta.url)
 export const MAX_ASSEMBLE_RECALL_CHARS = 1200
 const TRUNCATED_RECALL_SUFFIX = "\n\n[Basic Memory recall truncated]"
 const SUBAGENT_HANDOFF_FOLDER = "agent/subagents"
 const MAX_SUBAGENT_RECALL_CHARS = 800
 
+type BootstrapParams = Parameters<NonNullable<ContextEngine["bootstrap"]>>[0]
+type AssembleParams = Parameters<ContextEngine["assemble"]>[0]
+type AfterTurnParams = Parameters<NonNullable<ContextEngine["afterTurn"]>>[0]
+type CompactParams = Parameters<ContextEngine["compact"]>[0]
+type PrepareSubagentSpawnParams = Parameters<
+  NonNullable<ContextEngine["prepareSubagentSpawn"]>
+>[0]
+type OnSubagentEndedParams = Parameters<
+  NonNullable<ContextEngine["onSubagentEnded"]>
+>[0]
+
 interface SessionMemoryState {
   recallContext: string
 }
@@ -104,36 +112,6 @@ function buildSubagentCompletionUpdate(params: {
   ].join("\n")
 }
 
-type LegacyContextEngineModule = {
-  LegacyContextEngine: new () => {
-    compact(params: {
-      sessionId: string
-      sessionFile: string
-      tokenBudget?: number
-      force?: boolean
-      currentTokenCount?: number
-      compactionTarget?: "budget" | "threshold"
-      customInstructions?: string
-      runtimeContext?: Record<string, unknown>
-    }): Promise<CompactResult>
-  }
-}
-
-async function loadLegacyContextEngine(): Promise<
-  LegacyContextEngineModule["LegacyContextEngine"]
-> {
-  const pluginSdkPath = require.resolve("openclaw/plugin-sdk")
-  const legacyPath = resolve(
-    dirname(pluginSdkPath),
-    "context-engine",
-    "legacy.js",
-  )
-  const module = (await import(
-    pathToFileURL(legacyPath).href
-  )) as LegacyContextEngineModule
-  return module.LegacyContextEngine
-}
-
 export class BasicMemoryContextEngine implements ContextEngine {
   readonly info = {
     id: "openclaw-basic-memory",
@@ -144,19 +122,13 @@ export class BasicMemoryContextEngine implements ContextEngine {
 
   private readonly sessionState = new Map<string, SessionMemoryState>()
   private readonly subagentState = new Map<string, SubagentHandoffState>()
-  private legacyContextEnginePromise: Promise<
-    InstanceType<LegacyContextEngineModule["LegacyContextEngine"]>
-  > | null = null
 
   constructor(
     private readonly client: BmClient,
     private readonly cfg: BasicMemoryConfig,
   ) {}
 
-  async bootstrap(params: {
-    sessionId: string
-    sessionFile: string
-  }): Promise<BootstrapResult> {
+  async bootstrap(params: BootstrapParams): Promise<BootstrapResult> {
     if (!this.cfg.autoRecall) {
       this.sessionState.delete(params.sessionId)
       return { bootstrapped: false, reason: "autoRecall disabled" }
@@ -189,11 +161,7 @@ export class BasicMemoryContextEngine implements ContextEngine {
     return { ingested: false }
   }
 
-  async assemble(params: {
-    sessionId: string
-    messages: AgentMessage[]
-    tokenBudget?: number
-  }): Promise<AssembleResult> {
+  async assemble(params: AssembleParams): Promise<AssembleResult> {
     const state = this.sessionState.get(params.sessionId)
 
     return {
@@ -203,16 +171,7 @@ export class BasicMemoryContextEngine implements ContextEngine {
     }
   }
 
-  async afterTurn(params: {
-    sessionId: string
-    sessionFile: string
-    messages: AgentMessage[]
-    prePromptMessageCount: number
-    autoCompactionSummary?: string
-    isHeartbeat?: boolean
-    tokenBudget?: number
-    runtimeContext?: Record<string, unknown>
-  }): Promise<void> {
+  async afterTurn(params: AfterTurnParams): Promise<void> {
     if (!this.cfg.autoCapture) return
 
     const newMessages = params.messages.slice(params.prePromptMessageCount)
@@ -233,25 +192,13 @@ export class BasicMemoryContextEngine implements ContextEngine {
     }
   }
 
-  async compact(params: {
-    sessionId: string
-    sessionFile: string
-    tokenBudget?: number
-    force?: boolean
-    currentTokenCount?: number
-    compactionTarget?: "budget" | "threshold"
-    customInstructions?: string
-    runtimeContext?: Record<string, unknown>
-  }): Promise<CompactResult> {
-    const legacy = await this.getLegacyContextEngine()
-    return legacy.compact(params)
+  async compact(params: CompactParams): Promise<CompactResult> {
+    return delegateCompactionToRuntime(params)
   }
 
-  async prepareSubagentSpawn(params: {
-    parentSessionKey: string
-    childSessionKey: string
-    ttlMs?: number
-  }): Promise<{ rollback: () => Promise<void> } | undefined> {
+  async prepareSubagentSpawn(
+    params: PrepareSubagentSpawnParams,
+  ): Promise<SubagentSpawnPreparation | undefined> {
     const parentState = this.sessionState.get(params.parentSessionKey)
     const noteTitle = buildSubagentNoteTitle(params.childSessionKey)
 
@@ -291,10 +238,7 @@ export class BasicMemoryContextEngine implements ContextEngine {
     }
   }
 
-  async onSubagentEnded(params: {
-    childSessionKey: string
-    reason: "deleted" | "completed" | "swept" | "released"
-  }): Promise<void> {
+  async onSubagentEnded(params: OnSubagentEndedParams): Promise<void> {
     const handoff = this.subagentState.get(params.childSessionKey)
     if (!handoff) return
 
@@ -315,16 +259,4 @@ export class BasicMemoryContextEngine implements ContextEngine {
     this.sessionState.clear()
     this.subagentState.clear()
   }
-
-  private async getLegacyContextEngine(): Promise<
-    InstanceType<LegacyContextEngineModule["LegacyContextEngine"]>
-  > {
-    if (!this.legacyContextEnginePromise) {
-      this.legacyContextEnginePromise = loadLegacyContextEngine().then(
-        (LegacyContextEngine) => new LegacyContextEngine(),
-      )
-    }
-
-    return this.legacyContextEnginePromise
-  }
 }

package/dist/bm-client.d.ts

@@ -0,0 +1,179 @@
+export declare class NoteAlreadyExistsError extends Error {
+    readonly permalink: string;
+    constructor(title: string, permalink: string);
+}
+export interface SearchResult {
+    title: string;
+    permalink: string;
+    content: string;
+    score?: number;
+    file_path: string;
+}
+export interface NoteResult {
+    title: string;
+    permalink: string;
+    content: string;
+    file_path: string;
+    frontmatter?: Record<string, unknown> | null;
+    checksum?: string | null;
+    action?: "created" | "updated";
+}
+export interface EditNoteResult {
+    title: string;
+    permalink: string;
+    file_path: string;
+    operation: "append" | "prepend" | "find_replace" | "replace_section";
+    checksum?: string | null;
+}
+interface ReadNoteOptions {
+    includeFrontmatter?: boolean;
+}
+interface EditNoteOptions {
+    find_text?: string;
+    section?: string;
+    expected_replacements?: number;
+}
+export interface ContextResult {
+    results: Array<{
+        primary_result: NoteResult;
+        observations: Array<{
+            category: string;
+            content: string;
+        }>;
+        related_results: Array<{
+            type: "relation" | "entity";
+            title?: string;
+            permalink: string;
+            relation_type?: string;
+            from_entity?: string;
+            to_entity?: string;
+        }>;
+    }>;
+}
+export interface RecentResult {
+    title: string;
+    permalink: string;
+    file_path: string;
+    created_at: string;
+}
+export interface ProjectListResult {
+    name: string;
+    path: string;
+    display_name?: string | null;
+    is_private?: boolean;
+    is_default?: boolean;
+    isDefault?: boolean;
+    workspace_name?: string | null;
+    workspace_slug?: string | null;
+    workspace_type?: string | null;
+    workspace_tenant_id?: string | null;
+}
+export interface WorkspaceResult {
+    tenant_id: string;
+    name: string;
+    workspace_type: string;
+    role: string;
+    organization_id?: string | null;
+    has_active_subscription: boolean;
+}
+export interface SchemaValidationResult {
+    entity_type: string | null;
+    total_notes: number;
+    total_entities: number;
+    valid_count: number;
+    warning_count: number;
+    error_count: number;
+    results: Array<{
+        identifier: string;
+        valid: boolean;
+        warnings: string[];
+        errors: string[];
+    }>;
+}
+export interface SchemaInferResult {
+    entity_type: string;
+    notes_analyzed: number;
+    field_frequencies: Array<{
+        name: string;
+        percentage: number;
+        count: number;
+        total: number;
+        source: string;
+        sample_values?: string[];
+        is_array?: boolean;
+        target_type?: string | null;
+    }>;
+    suggested_schema: Record<string, unknown>;
+    suggested_required: string[];
+    suggested_optional: string[];
+    excluded: string[];
+}
+export interface SchemaDiffResult {
+    entity_type: string;
+    schema_found: boolean;
+    new_fields: Array<{
+        name: string;
+        source: string;
+        count: number;
+        total: number;
+        percentage: number;
+    }>;
+    dropped_fields: Array<{
+        name: string;
+        source: string;
+        declared_in?: string;
+    }>;
+    cardinality_changes: string[];
+}
+export declare class BmClient {
+    private bmPath;
+    private project;
+    private cwd?;
+    private env?;
+    private shouldRun;
+    private client;
+    private transport;
+    private connectPromise;
+    private retryDelaysMs;
+    constructor(bmPath: string, project: string);
+    start(options?: {
+        cwd?: string;
+        env?: Record<string, string>;
+    }): Promise<void>;
+    stop(): Promise<void>;
+    private connectWithRetries;
+    private ensureConnected;
+    private connectFresh;
+    private assertRequiredTools;
+    private disconnectCurrent;
+    private callToolRaw;
+    private callTool;
+    private routedProject;
+    ensureProject(projectPath: string): Promise<void>;
+    listWorkspaces(): Promise<WorkspaceResult[]>;
+    listProjects(workspace?: string): Promise<ProjectListResult[]>;
+    search(query?: string, limit?: number, project?: string, metadata?: {
+        filters?: Record<string, unknown>;
+        tags?: string[];
+        status?: string;
+        note_types?: string[];
+        entity_types?: string[];
+    }): Promise<SearchResult[]>;
+    readNote(identifier: string, options?: ReadNoteOptions, project?: string): Promise<NoteResult>;
+    writeNote(title: string, content: string, folder: string, project?: string, overwrite?: boolean): Promise<NoteResult>;
+    buildContext(url: string, depth?: number, project?: string): Promise<ContextResult>;
+    recentActivity(timeframe?: string, project?: string): Promise<RecentResult[]>;
+    editNote(identifier: string, operation: "append" | "prepend" | "find_replace" | "replace_section", content: string, options?: EditNoteOptions, project?: string): Promise<EditNoteResult>;
+    deleteNote(identifier: string, project?: string): Promise<{
+        title: string;
+        permalink: string;
+        file_path: string;
+    }>;
+    moveNote(identifier: string, newFolder: string, project?: string): Promise<NoteResult>;
+    schemaValidate(noteType?: string, identifier?: string, project?: string): Promise<SchemaValidationResult>;
+    schemaInfer(noteType: string, threshold?: number, project?: string): Promise<SchemaInferResult>;
+    schemaDiff(noteType: string, project?: string): Promise<SchemaDiffResult>;
+    indexConversation(userMessage: string, assistantResponse: string): Promise<void>;
+    getProject(): string;
+}
+export {};