import { ShelMem, openaiEmbeddings } from '@forestinfra/shelmem';

const mem = new ShelMem({
  supabaseUrl: process.env.SUPABASE_URL,
  supabaseKey: process.env.SUPABASE_KEY,
  encrypt: true,
  embeddingProvider: openaiEmbeddings(OPENAI_KEY),
});

const result = await mem.write(
  'agent-001', 'User prefers dark mode', 'preferences', 'preference'
);
// → { content_hash, shelby_object_id, aptos_tx_hash }

const memories = await mem.recall('agent-001', 'preferences');
for (const m of memories) {
  console.log(m.memory, m.verified); // true | false | null
}

const results = await mem.search('what does the user prefer?');
// → [{ memory_preview, similarity: 0.91 }]

await mem.recordTransaction({
  agentId: 'trading-agent',
  memory: 'Paid 100 APT for API access',
  context: 'payments',
  amount: 100,
  currency: 'APT',
  counterparty: '0xmerchant...',
});
// → { memory_type: 'transaction_record', tx_status: 'pending', ... }

await mem.recordBalanceSnapshot({
  agentId: 'trading-agent',
  memory: 'End-of-day balance',
  context: 'treasury',
  amount: 4725,
  currency: 'APT',
});

const balance = await mem.getLatestBalance('trading-agent');
// → { amount: 4725, currency: 'APT', memory_type: 'balance_snapshot' }
// → null if no balance snapshots exist

const pool = await mem.createPool({
  name: 'market-ops',
  ownerAgentId: 'trading-agent',
});

await mem.addPoolMember(pool.id, 'trading-agent', 'execution-agent', 'writer');
await mem.addPoolMember(pool.id, 'trading-agent', 'risk-agent',      'writer');
await mem.addPoolMember(pool.id, 'trading-agent', 'reporting-agent', 'reader');

await mem.writeToPool({
  poolId: pool.id, agentId: 'trading-agent',
  memory: 'RSI=35, buy 500 APT', context: 'trading',
  memory_type: 'decision',
});

const records = await mem.recallFromPool({
  poolId: pool.id, agentId: 'reporting-agent',
});
// → each record carries agent_id (writer) and pool_id, plus the verified content

import { PermissionError } from '@forestinfra/shelmem';

try {
  await mem.writeToPool({
    poolId: pool.id, agentId: 'reporting-agent',
    memory: 'denied', context: 'trading',
  });
} catch (err) {
  if (err instanceof PermissionError) {
    // role 'reader' cannot write
  }
}

// Writer side
await mem.write(
  'trading-agent', 'sensitive insight', 'analysis', 'observation',
  /* metadata */ undefined, /* treasury */ undefined,
  /* sharedWith */ ['execution-agent', 'risk-agent'],
);

// Reader side
const visible = await mem.recallShared('execution-agent');

const log = await mem.getPoolAuditLog(pool.id, 'trading-agent');
// → [{ action: 'read',  agent_id: 'reporting-agent', result_count: 3,  created_at },
//    { action: 'write', agent_id: 'risk-agent',      memory_id: '...', created_at }]

import { signAgentClaim, verifyAgentClaim } from '@forestinfra/shelmem';

// Agent side: produce a short-lived signed claim
const claim = signAgentClaim('trading-agent', process.env.AGENT_PRIVATE_KEY);
// → { agentId, timestamp, publicKey, signature }

// Verifier side: registry maps agent_id → expected pubkey
const expectedPub = REGISTRY['trading-agent'];
verifyAgentClaim(claim, 'trading-agent', expectedPub); // throws AgentClaimError on failure

const mem = new ShelMem({
  supabaseUrl, supabaseKey,
  aptosPrivateKey: '0x...',
  encrypt: true,
});
// Write encrypted, recall decrypted, hash verified on plaintext

import { ShelMem, openaiEmbeddings } from '@forestinfra/shelmem';

const mem = new ShelMem({
  supabaseUrl, supabaseKey,
  embeddingProvider: openaiEmbeddings(process.env.OPENAI_API_KEY),
});

await mem.write('agent', 'ETH RSI is 28', 'analysis', 'observation');
const results = await mem.search('ethereum price?', 'agent');
// → [{ memory_preview: 'ETH RSI is 28', similarity: 0.87 }]

from shelmem.integrations.langchain import ShelMemChatMessageHistory

history = ShelMemChatMessageHistory(
    session_id="user-123", agent_id="my-chatbot",
    supabase_url=url, supabase_key=key,
)

from langchain_core.runnables.history import RunnableWithMessageHistory
chain_with_history = RunnableWithMessageHistory(chain, lambda sid: history)

from shelmem.integrations.crewai import ShelMemStorage
crew = Crew(
    agents=[...], tasks=[...], memory=True,
    short_term_memory=ShortTermMemory(storage=ShelMemStorage(
        crew_id="my-crew", supabase_url=url, supabase_key=key,
    )),
)

import { createShelMemTools } from '@forestinfra/shelmem';
const tools = createShelMemTools({
  agentId: 'my-agent',
  supabaseUrl: process.env.SUPABASE_URL,
  supabaseKey: process.env.SUPABASE_KEY,
});
// gives agents memorize + remember tools

CREATE EXTENSION IF NOT EXISTS vector;

CREATE TABLE IF NOT EXISTS memories (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  agent_id TEXT NOT NULL, context TEXT NOT NULL,
  memory_preview TEXT, shelby_object_id TEXT NOT NULL,
  aptos_tx_hash TEXT, content_hash CHAR(64),
  memory_type TEXT DEFAULT 'observation',
  verified BOOLEAN, embedding vector(1536),
  amount NUMERIC, currency TEXT,
  counterparty TEXT, tx_status TEXT,
  metadata JSONB DEFAULT '{}',
  created_at TIMESTAMPTZ DEFAULT now(),
  updated_at TIMESTAMPTZ DEFAULT now()
);

CREATE INDEX idx_memories_agent_id ON memories(agent_id);
CREATE INDEX idx_memories_agent_context ON memories(agent_id, context);
CREATE INDEX idx_memories_created_at ON memories(created_at DESC);
CREATE INDEX idx_memories_type ON memories(agent_id, memory_type);
CREATE INDEX idx_memories_embedding ON memories USING hnsw (embedding vector_cosine_ops);
ALTER TABLE memories ENABLE ROW LEVEL SECURITY;
CREATE POLICY "Allow all" ON memories FOR ALL USING (true) WITH CHECK (true);

-- Shared pools (migration-v5)
CREATE TABLE memory_pools (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  name TEXT NOT NULL, description TEXT,
  owner_agent_id TEXT NOT NULL,
  metadata JSONB DEFAULT '{}',
  created_at TIMESTAMPTZ DEFAULT now(),
  updated_at TIMESTAMPTZ DEFAULT now()
);
CREATE TABLE pool_members (
  pool_id UUID REFERENCES memory_pools(id) ON DELETE CASCADE,
  agent_id TEXT NOT NULL,
  role TEXT CHECK (role IN ('owner','writer','reader')),
  added_at TIMESTAMPTZ DEFAULT now(),
  PRIMARY KEY (pool_id, agent_id)
);
ALTER TABLE memories ADD COLUMN pool_id UUID
  REFERENCES memory_pools(id) ON DELETE SET NULL;

-- ACLs + audit log + pool semantic search (migration-v6)
ALTER TABLE memories ADD COLUMN shared_with TEXT[] DEFAULT '{}';
CREATE INDEX idx_memories_shared_with ON memories USING gin (shared_with);

CREATE TABLE pool_access_log (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  pool_id UUID REFERENCES memory_pools(id) ON DELETE CASCADE,
  agent_id TEXT NOT NULL,
  action TEXT CHECK (action IN ('write','read')),
  memory_id UUID REFERENCES memories(id) ON DELETE SET NULL,
  result_count INT, metadata JSONB DEFAULT '{}',
  created_at TIMESTAMPTZ DEFAULT now()
);
-- Plus the match_pool_memories pgvector RPC — see migration-v6.sql.

Agent → ShelMem SDK → [SHA-256 hash] → [AES-256 encrypt]
                    → Shelby Protocol (encrypted content)
                    → Supabase (metadata + embeddings)
                    → Aptos (on-chain proof)

Recall ← [verify hash] ← [decrypt] ← Shelby download
       ← Supabase metadata query