import { XacheClient } from '@xache/sdk';

const client = new XacheClient({
  apiUrl: 'https://api.xache.xyz',
  did: 'did:agent:evm:0xYourWalletAddress',
  privateKey: '0x...',
});

// Register identity
const identity = await client.identity.register({
  walletAddress: '0xYourWalletAddress',
  keyType: 'evm',
  chain: 'base',
});

console.log('DID:', identity.did);

// Store encrypted memory (automatic encryption + 402 payment)
const memory = await client.memory.store({
  data: { context: 'user preferences', theme: 'dark' },
  storageTier: 'hot',
  tags: ['settings'],
});

console.log('Storage Key:', memory.storageKey);

// Retrieve memory (automatic decryption + 402 payment)
const retrieved = await client.memory.retrieve({
  storageKey: memory.storageKey,
});

console.log('Data:', retrieved.data);

// List and delete
const list = await client.memory.list({ limit: 20 });
await client.memory.delete(memory.storageKey);

const batchResult = await client.memory.storeBatch({
  items: [
    { data: { key: 'value1' }, storageTier: 'hot' },
    { data: { key: 'value2' }, storageTier: 'warm' },
  ],
});

const retrieveResult = await client.memory.retrieveBatch({
  storageKeys: ['mem_123', 'mem_456'],
});

// Contribute a heuristic (automatic 402 payment)
const heuristic = await client.collective.contribute({
  pattern: 'Use async/await for cleaner async code',
  patternHash: hashPattern(pattern),
  domain: 'javascript',
  tags: ['async', 'best-practices'],
  metrics: { successRate: 0.85, sampleSize: 10, confidence: 0.9 },
  encryptedContentRef: patternHash,
});

// Query collective
const results = await client.collective.query({
  queryText: 'How to optimize database queries in Node.js',
  domain: 'nodejs',
  limit: 10,
});

// Create an ephemeral session (x402 payment: $0.005)
const session = await client.ephemeral.createSession({
  ttlSeconds: 3600,   // 1 hour
  maxWindows: 5,
});

console.log('Session:', session.sessionKey);
console.log('Expires:', session.expiresAt);

// Write to slots (free while session is active)
await client.ephemeral.writeSlot(session.sessionKey, 'facts', {
  userName: 'Alice',
  preference: 'dark_mode',
});

await client.ephemeral.writeSlot(session.sessionKey, 'tasks', {
  pending: ['research quantum computing', 'write summary'],
});

// Read from a slot
const facts = await client.ephemeral.readSlot(session.sessionKey, 'facts');
console.log('Facts:', facts);

// Read all slots at once
const allSlots = await client.ephemeral.readAllSlots(session.sessionKey);

// Promote to persistent memory when session is valuable ($0.05)
const result = await client.ephemeral.promoteSession(session.sessionKey);
console.log(`Created ${result.memoriesCreated} memories`);
console.log('Memory IDs:', result.memoryIds);

// Or terminate if no longer needed (free)
await client.ephemeral.terminateSession(session.sessionKey);

// List active sessions
const sessions = await client.ephemeral.listSessions({ status: 'active' });

// Renew an expiring session
const renewed = await client.ephemeral.renewSession(session.sessionKey);

// Get structured view (entities + relationships extracted from session data)
const structured = await client.ephemeral.getStructured(session.sessionKey);

// Export session data
const exported = await client.ephemeral.exportSession(session.sessionKey, 'json');

// Get usage stats
const stats = await client.ephemeral.getStats();
console.log('Active sessions:', stats.activeSessions);
console.log('Promote rate:', stats.promoteRate);

// Extract entities from text
const extracted = await client.graph.extract({
  trace: 'Alice works at Acme Corp as a senior engineer.',
  contextHint: 'engineering',
});

// Query around an entity
const neighbors = await client.graph.query({
  startEntity: 'Alice',
  depth: 2,
});

// Ask natural language questions
const answer = await client.graph.ask({
  question: 'Who works at Acme Corp?',
});

// Load the full graph
const graph = await client.graph.load();

const budget = await client.budget.getStatus();
console.log(`Limit: $${budget.limitCents / 100}`);
console.log(`Spent: $${budget.spentCents / 100}`);

await client.budget.updateLimit(5000); // $50/month

client.budget.onAlert((alert) => {
  console.log(`Budget Alert: ${alert.level} - ${alert.message}`);
});

const reputation = await client.reputation.getReputation();
console.log('Overall Score:', reputation.overall);

const topAgents = await client.reputation.getTopAgents(10);

const client = new XacheClient({
  apiUrl: 'https://api.xache.xyz',
  did: 'did:agent:evm:0xYourWalletAddress',
  privateKey: '0x...',
  timeout: 30000,
  debug: false,
});

import {
  PaymentRequiredError,
  RateLimitedError,
  BudgetExceededError,
  NetworkError,
} from '@xache/sdk';

try {
  await client.memory.store({ data, storageTier: 'hot' });
} catch (error) {
  if (error instanceof PaymentRequiredError) {
    console.log('Payment required:', error.amount);
  } else if (error instanceof RateLimitedError) {
    console.log('Rate limited. Retry at:', error.resetAt);
  }
}

const session = await client.sessions.create({
  walletAddress: '0xYourWalletAddress',
  chain: 'evm',
  network: 'base-sepolia',
  scope: ['memory:store', 'memory:retrieve'],
  durationSeconds: 3600,
  maxAmount: '10000000',
});

client.sessions.setCurrentSession(session.sessionId);
// All subsequent requests use the session automatically

const facilitators = await client.facilitators.list();

client.facilitators.setPreferences({
  preferredFacilitators: ['cdp'],
  preferredChain: 'solana',
});

const subjectId = await client.deriveSubjectId('customer_12345');

await client.memory.store({
  data: { preference: 'dark_mode' },
  storageTier: 'hot',
  subject: client.createSubjectContext(subjectId),
});