@claude-flow/plugin-gastown-bridge 0.1.0

package/dist/bridges.d.ts

@@ -0,0 +1,924 @@
+import { z } from 'zod';
+import { ChildProcess } from 'child_process';
+
+/**
+ * Gas Town CLI Bridge
+ *
+ * Provides a secure wrapper around the `gt` (Gas Town) CLI tool.
+ * Implements command execution with proper input sanitization,
+ * argument validation, and error handling.
+ *
+ * Security Features:
+ * - All inputs validated with Zod schemas
+ * - No shell execution (uses execFile)
+ * - Command allowlist enforcement
+ * - Argument sanitization
+ *
+ * @module v3/plugins/gastown-bridge/bridges/gt-bridge
+ */
+
+/**
+ * Safe string pattern - no shell metacharacters
+ */
+declare const SafeStringSchema: z.ZodEffects<z.ZodString, string, string>;
+/**
+ * Safe identifier pattern - alphanumeric with underscore/hyphen
+ */
+declare const IdentifierSchema: z.ZodString;
+/**
+ * Gas price schema
+ */
+declare const GasPriceSchema: z.ZodNumber;
+/**
+ * Gas limit schema
+ */
+declare const GasLimitSchema: z.ZodNumber;
+/**
+ * Transaction hash schema (0x prefixed hex)
+ */
+declare const TxHashSchema: z.ZodString;
+/**
+ * Address schema (0x prefixed hex)
+ */
+declare const AddressSchema: z.ZodString;
+/**
+ * Network schema
+ */
+declare const NetworkSchema: z.ZodEnum<["mainnet", "goerli", "sepolia", "polygon", "arbitrum", "optimism", "base", "local"]>;
+/**
+ * GT command argument schema
+ */
+declare const GtArgumentSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+/**
+ * Gas Town executor configuration
+ */
+interface GtBridgeConfig {
+    /**
+     * Path to gt executable
+     * Default: 'gt' (assumes in PATH)
+     */
+    gtPath?: string;
+    /**
+     * Working directory for execution
+     */
+    cwd?: string;
+    /**
+     * Execution timeout in milliseconds
+     * Default: 30000 (30 seconds)
+     */
+    timeout?: number;
+    /**
+     * Maximum buffer size for output
+     * Default: 10MB
+     */
+    maxBuffer?: number;
+    /**
+     * Environment variables
+     */
+    env?: NodeJS.ProcessEnv;
+    /**
+     * Default network
+     */
+    defaultNetwork?: z.infer<typeof NetworkSchema>;
+}
+/**
+ * Gas estimation result
+ */
+interface GasEstimate {
+    gasLimit: number;
+    gasPrice: string;
+    maxFeePerGas?: string;
+    maxPriorityFeePerGas?: string;
+    estimatedCost: string;
+    estimatedCostUsd?: number;
+}
+/**
+ * Transaction status
+ */
+interface TxStatus {
+    hash: string;
+    status: 'pending' | 'confirmed' | 'failed' | 'dropped';
+    blockNumber?: number;
+    confirmations?: number;
+    gasUsed?: number;
+    effectiveGasPrice?: string;
+    error?: string;
+}
+/**
+ * Network status
+ */
+interface NetworkStatus {
+    network: string;
+    chainId: number;
+    blockNumber: number;
+    baseFee?: string;
+    gasPrice?: string;
+    connected: boolean;
+}
+/**
+ * GT execution result
+ */
+interface GtResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    command: string;
+    args: string[];
+    durationMs: number;
+}
+/**
+ * Logger interface
+ */
+interface GtLogger {
+    debug: (msg: string, meta?: Record<string, unknown>) => void;
+    info: (msg: string, meta?: Record<string, unknown>) => void;
+    warn: (msg: string, meta?: Record<string, unknown>) => void;
+    error: (msg: string, meta?: Record<string, unknown>) => void;
+}
+/**
+ * Gas Town bridge error codes
+ */
+type GtErrorCode = 'COMMAND_NOT_FOUND' | 'EXECUTION_FAILED' | 'TIMEOUT' | 'INVALID_ARGUMENT' | 'INVALID_OUTPUT' | 'NETWORK_ERROR' | 'VALIDATION_ERROR';
+/**
+ * Gas Town bridge error
+ */
+declare class GtBridgeError extends Error {
+    readonly code: GtErrorCode;
+    readonly command?: string | undefined;
+    readonly args?: string[] | undefined;
+    readonly cause?: Error | undefined;
+    constructor(message: string, code: GtErrorCode, command?: string | undefined, args?: string[] | undefined, cause?: Error | undefined);
+}
+/**
+ * Gas Town CLI Bridge
+ *
+ * Secure wrapper around the `gt` CLI tool for gas estimation
+ * and transaction management.
+ *
+ * @example
+ * ```typescript
+ * const gtBridge = new GtBridge({ gtPath: '/usr/local/bin/gt' });
+ * await gtBridge.initialize();
+ *
+ * const estimate = await gtBridge.estimateGas({
+ *   to: '0x...',
+ *   data: '0x...',
+ *   network: 'mainnet',
+ * });
+ * ```
+ */
+declare class GtBridge {
+    private config;
+    private logger;
+    private initialized;
+    /** Commands that can be cached (read-only, no side effects) */
+    private static readonly CACHEABLE_COMMANDS;
+    /** Commands that should use longer cache (static data) */
+    private static readonly STATIC_COMMANDS;
+    constructor(config?: GtBridgeConfig, logger?: GtLogger);
+    /**
+     * Initialize the bridge and verify gt is available
+     */
+    initialize(): Promise<void>;
+    /**
+     * Execute a gt command with validated arguments
+     *
+     * @param args - Command arguments (validated and sanitized)
+     * @returns Command output
+     */
+    execGt(args: string[], skipCache?: boolean): Promise<GtResult<string>>;
+    /**
+     * Parse JSON output from gt command
+     *
+     * @param output - Raw command output
+     * @returns Parsed JSON object
+     */
+    parseGtOutput<T>(output: string): T;
+    /**
+     * Estimate gas for a transaction
+     */
+    estimateGas(params: {
+        to: string;
+        data?: string;
+        value?: string;
+        from?: string;
+        network?: z.infer<typeof NetworkSchema>;
+    }): Promise<GasEstimate>;
+    /**
+     * Get transaction status
+     */
+    getTxStatus(txHash: string, network?: z.infer<typeof NetworkSchema>): Promise<TxStatus>;
+    /**
+     * Get network status
+     */
+    getNetworkStatus(network?: z.infer<typeof NetworkSchema>): Promise<NetworkStatus>;
+    /**
+     * Get current gas price
+     */
+    getGasPrice(network?: z.infer<typeof NetworkSchema>): Promise<{
+        gasPrice: string;
+        maxFeePerGas?: string;
+        maxPriorityFeePerGas?: string;
+        baseFee?: string;
+    }>;
+    /**
+     * Simulate a transaction
+     */
+    simulate(params: {
+        to: string;
+        data: string;
+        value?: string;
+        from?: string;
+        network?: z.infer<typeof NetworkSchema>;
+        blockNumber?: number;
+    }): Promise<{
+        success: boolean;
+        returnData?: string;
+        gasUsed?: number;
+        logs?: unknown[];
+        error?: string;
+    }>;
+    /**
+     * Decode transaction data
+     */
+    decode(data: string, abi?: string): Promise<{
+        method: string;
+        args: unknown[];
+        signature: string;
+    }>;
+    /**
+     * Validate and sanitize command arguments
+     */
+    private validateAndSanitizeArgs;
+    /**
+     * Ensure bridge is initialized
+     */
+    private ensureInitialized;
+    /**
+     * Check if bridge is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Get current configuration
+     */
+    getConfig(): Readonly<Required<GtBridgeConfig>>;
+    /**
+     * Get cache statistics for performance monitoring
+     */
+    getCacheStats(): {
+        resultCache: {
+            entries: number;
+            sizeBytes: number;
+        };
+        staticCache: {
+            entries: number;
+            sizeBytes: number;
+        };
+        parsedCache: {
+            entries: number;
+            sizeBytes: number;
+        };
+    };
+    /**
+     * Clear all caches (useful for testing or memory pressure)
+     */
+    clearCaches(): void;
+}
+/**
+ * Create a new Gas Town bridge instance
+ */
+declare function createGtBridge(config?: GtBridgeConfig, logger?: GtLogger): GtBridge;
+
+/**
+ * Beads CLI Bridge
+ *
+ * Provides a secure wrapper around the `bd` (Beads) CLI tool.
+ * Implements command execution with proper input sanitization,
+ * argument validation, JSONL parsing, and error handling.
+ *
+ * Security Features:
+ * - All inputs validated with Zod schemas
+ * - No shell execution (uses execFile)
+ * - Command allowlist enforcement
+ * - Argument sanitization
+ * - JSONL streaming support
+ *
+ * @module v3/plugins/gastown-bridge/bridges/bd-bridge
+ */
+
+/**
+ * Bead ID schema (UUID or custom format)
+ */
+declare const BeadIdSchema: z.ZodString;
+/**
+ * Bead type schema
+ */
+declare const BeadTypeSchema: z.ZodEnum<["prompt", "response", "code", "context", "memory", "tool-call", "tool-result", "system", "error", "metadata"]>;
+/**
+ * Bead schema
+ */
+declare const BeadSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<["prompt", "response", "code", "context", "memory", "tool-call", "tool-result", "system", "error", "metadata"]>;
+    content: z.ZodString;
+    timestamp: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    parentId: z.ZodOptional<z.ZodString>;
+    threadId: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    embedding: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    hash: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "error" | "metadata" | "code" | "prompt" | "response" | "context" | "memory" | "tool-call" | "tool-result" | "system";
+    id: string;
+    content: string;
+    metadata?: Record<string, unknown> | undefined;
+    embedding?: number[] | undefined;
+    parentId?: string | undefined;
+    timestamp?: string | undefined;
+    threadId?: string | undefined;
+    agentId?: string | undefined;
+    tags?: string[] | undefined;
+    hash?: string | undefined;
+}, {
+    type: "error" | "metadata" | "code" | "prompt" | "response" | "context" | "memory" | "tool-call" | "tool-result" | "system";
+    id: string;
+    content: string;
+    metadata?: Record<string, unknown> | undefined;
+    embedding?: number[] | undefined;
+    parentId?: string | undefined;
+    timestamp?: string | undefined;
+    threadId?: string | undefined;
+    agentId?: string | undefined;
+    tags?: string[] | undefined;
+    hash?: string | undefined;
+}>;
+/**
+ * BD command argument schema
+ */
+declare const BdArgumentSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+/**
+ * Bead type (inferred from schema)
+ */
+type Bead = z.infer<typeof BeadSchema>;
+/**
+ * Bead type enum
+ */
+type BeadType = z.infer<typeof BeadTypeSchema>;
+/**
+ * Beads bridge configuration
+ */
+interface BdBridgeConfig {
+    /**
+     * Path to bd executable
+     * Default: 'bd' (assumes in PATH)
+     */
+    bdPath?: string;
+    /**
+     * Working directory for execution
+     */
+    cwd?: string;
+    /**
+     * Execution timeout in milliseconds
+     * Default: 60000 (60 seconds)
+     */
+    timeout?: number;
+    /**
+     * Maximum buffer size for output
+     * Default: 50MB (beads can be large)
+     */
+    maxBuffer?: number;
+    /**
+     * Environment variables
+     */
+    env?: NodeJS.ProcessEnv;
+    /**
+     * Default storage path
+     */
+    storagePath?: string;
+}
+/**
+ * Bead query parameters
+ */
+interface BeadQuery {
+    type?: BeadType | BeadType[];
+    threadId?: string;
+    agentId?: string;
+    tags?: string[];
+    after?: string;
+    before?: string;
+    limit?: number;
+    offset?: number;
+    sortBy?: 'timestamp' | 'id' | 'type';
+    sortOrder?: 'asc' | 'desc';
+}
+/**
+ * Bead creation parameters
+ */
+interface CreateBeadParams {
+    type: BeadType;
+    content: string;
+    parentId?: string;
+    threadId?: string;
+    agentId?: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * BD execution result
+ */
+interface BdResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    command: string;
+    args: string[];
+    durationMs: number;
+}
+/**
+ * Streaming execution result
+ */
+interface BdStreamResult {
+    process: ChildProcess;
+    stdout: NodeJS.ReadableStream | null;
+    stderr: NodeJS.ReadableStream | null;
+    promise: Promise<BdResult<string>>;
+}
+/**
+ * Logger interface
+ */
+interface BdLogger {
+    debug: (msg: string, meta?: Record<string, unknown>) => void;
+    info: (msg: string, meta?: Record<string, unknown>) => void;
+    warn: (msg: string, meta?: Record<string, unknown>) => void;
+    error: (msg: string, meta?: Record<string, unknown>) => void;
+}
+/**
+ * Beads bridge error codes
+ */
+type BdErrorCode = 'COMMAND_NOT_FOUND' | 'EXECUTION_FAILED' | 'TIMEOUT' | 'INVALID_ARGUMENT' | 'INVALID_OUTPUT' | 'PARSE_ERROR' | 'VALIDATION_ERROR' | 'BEAD_NOT_FOUND';
+/**
+ * Beads bridge error
+ */
+declare class BdBridgeError extends Error {
+    readonly code: BdErrorCode;
+    readonly command?: string | undefined;
+    readonly args?: string[] | undefined;
+    readonly cause?: Error | undefined;
+    constructor(message: string, code: BdErrorCode, command?: string | undefined, args?: string[] | undefined, cause?: Error | undefined);
+}
+/**
+ * Beads CLI Bridge
+ *
+ * Secure wrapper around the `bd` CLI tool for bead management.
+ * Supports JSONL output parsing for streaming large datasets.
+ *
+ * @example
+ * ```typescript
+ * const bdBridge = new BdBridge({ bdPath: '/usr/local/bin/bd' });
+ * await bdBridge.initialize();
+ *
+ * const beads = await bdBridge.listBeads({ type: 'prompt', limit: 100 });
+ * ```
+ */
+declare class BdBridge {
+    private config;
+    private logger;
+    private initialized;
+    /** Commands that can be cached (read-only, no side effects) */
+    private static readonly CACHEABLE_COMMANDS;
+    /** Commands that should use longer cache (static data) */
+    private static readonly STATIC_COMMANDS;
+    constructor(config?: BdBridgeConfig, logger?: BdLogger);
+    /**
+     * Initialize the bridge and verify bd is available
+     */
+    initialize(): Promise<void>;
+    /**
+     * Execute a bd command with validated arguments
+     *
+     * @param args - Command arguments (validated and sanitized)
+     * @returns Command output
+     */
+    execBd(args: string[], skipCache?: boolean): Promise<BdResult<string>>;
+    /**
+     * Execute bd command with streaming output
+     */
+    execBdStreaming(args: string[]): BdStreamResult;
+    /**
+     * Parse JSONL output from bd command into Bead array
+     *
+     * @param output - JSONL formatted output
+     * @returns Array of parsed and validated beads
+     */
+    parseBdOutput(output: string): Bead[];
+    /**
+     * Parse single bead from JSON output
+     */
+    parseSingleBead(output: string): Bead;
+    /**
+     * List beads with optional query parameters
+     */
+    listBeads(query?: BeadQuery): Promise<Bead[]>;
+    /**
+     * Get a single bead by ID
+     */
+    getBead(beadId: string): Promise<Bead>;
+    /**
+     * Create a new bead
+     */
+    createBead(params: CreateBeadParams): Promise<Bead>;
+    /**
+     * Search beads with semantic query
+     */
+    searchBeads(query: string, options?: {
+        limit?: number;
+        threshold?: number;
+        type?: BeadType | BeadType[];
+    }): Promise<Bead[]>;
+    /**
+     * Export beads to JSONL format
+     */
+    exportBeads(query?: BeadQuery): Promise<string>;
+    /**
+     * Get bead statistics
+     */
+    getStats(): Promise<{
+        totalBeads: number;
+        beadsByType: Record<string, number>;
+        totalThreads: number;
+        oldestBead?: string;
+        newestBead?: string;
+        storageSize?: number;
+    }>;
+    /**
+     * Validate and sanitize command arguments
+     */
+    private validateAndSanitizeArgs;
+    /**
+     * Ensure bridge is initialized
+     */
+    private ensureInitialized;
+    /**
+     * Check if bridge is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Get current configuration
+     */
+    getConfig(): Readonly<Required<BdBridgeConfig>>;
+    /**
+     * Get cache statistics for performance monitoring
+     */
+    getCacheStats(): {
+        beadQueryCache: {
+            entries: number;
+            sizeBytes: number;
+        };
+        singleBeadCache: {
+            entries: number;
+            sizeBytes: number;
+        };
+        staticCache: {
+            entries: number;
+            sizeBytes: number;
+        };
+        parsedCache: {
+            entries: number;
+            sizeBytes: number;
+        };
+    };
+    /**
+     * Clear all caches (useful for testing or memory pressure)
+     */
+    clearCaches(): void;
+    /**
+     * Invalidate cache for a specific bead (after create/update/delete)
+     */
+    invalidateBeadCache(beadId: string): void;
+}
+/**
+ * Create a new Beads bridge instance
+ */
+declare function createBdBridge(config?: BdBridgeConfig, logger?: BdLogger): BdBridge;
+
+/**
+ * Beads-AgentDB Sync Bridge
+ *
+ * Provides bidirectional synchronization between Beads (bd)
+ * and AgentDB. Implements conflict resolution strategies
+ * and maintains consistency between the two systems.
+ *
+ * Features:
+ * - Bidirectional sync (Beads <-> AgentDB)
+ * - Conflict resolution strategies
+ * - Incremental sync support
+ * - Transaction-safe operations
+ * - Embedding preservation
+ *
+ * @module v3/plugins/gastown-bridge/bridges/sync-bridge
+ */
+
+/**
+ * Sync conflict resolution strategy
+ */
+declare const ConflictStrategySchema: z.ZodEnum<["beads-wins", "agentdb-wins", "newest-wins", "merge", "manual"]>;
+/**
+ * Sync direction
+ */
+declare const SyncDirectionSchema: z.ZodEnum<["to-agentdb", "from-agentdb", "bidirectional"]>;
+/**
+ * Sync status
+ */
+declare const SyncStatusSchema: z.ZodEnum<["pending", "in-progress", "completed", "failed", "conflict"]>;
+/**
+ * AgentDB entry schema (compatible with claude-flow memory)
+ */
+declare const AgentDBEntrySchema: z.ZodObject<{
+    key: z.ZodString;
+    value: z.ZodUnknown;
+    namespace: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    embedding: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    namespace?: string | undefined;
+    version?: number | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    value?: unknown;
+    embedding?: number[] | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}, {
+    key: string;
+    namespace?: string | undefined;
+    version?: number | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    value?: unknown;
+    embedding?: number[] | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}>;
+/**
+ * Conflict resolution strategy type
+ */
+type ConflictStrategy = z.infer<typeof ConflictStrategySchema>;
+/**
+ * Sync direction type
+ */
+type SyncDirection = z.infer<typeof SyncDirectionSchema>;
+/**
+ * Sync status type
+ */
+type SyncStatus = z.infer<typeof SyncStatusSchema>;
+/**
+ * AgentDB entry type
+ */
+type AgentDBEntry = z.infer<typeof AgentDBEntrySchema>;
+/**
+ * Sync bridge configuration
+ */
+interface SyncBridgeConfig {
+    /**
+     * Beads bridge configuration
+     */
+    beadsBridge?: BdBridgeConfig;
+    /**
+     * AgentDB namespace for beads
+     * Default: 'beads'
+     */
+    agentdbNamespace?: string;
+    /**
+     * Conflict resolution strategy
+     * Default: 'newest-wins'
+     */
+    conflictStrategy?: ConflictStrategy;
+    /**
+     * Batch size for sync operations
+     * Default: 100
+     */
+    batchSize?: number;
+    /**
+     * Whether to preserve embeddings during sync
+     * Default: true
+     */
+    preserveEmbeddings?: boolean;
+    /**
+     * Whether to sync metadata
+     * Default: true
+     */
+    syncMetadata?: boolean;
+}
+/**
+ * Sync operation result
+ */
+interface SyncResult {
+    success: boolean;
+    direction: SyncDirection;
+    synced: number;
+    created: number;
+    updated: number;
+    deleted: number;
+    conflicts: number;
+    errors: Array<{
+        id: string;
+        error: string;
+    }>;
+    durationMs: number;
+    timestamp: string;
+}
+/**
+ * Conflict record
+ */
+interface SyncConflict {
+    beadId: string;
+    beadData: Bead;
+    agentdbData: AgentDBEntry;
+    conflictType: 'update' | 'delete' | 'create';
+    resolution?: 'beads' | 'agentdb' | 'merged' | 'pending';
+    resolvedAt?: string;
+}
+/**
+ * Sync state for incremental sync
+ */
+interface SyncState {
+    lastSyncTime: string;
+    lastBeadId?: string;
+    lastAgentDBKey?: string;
+    pendingConflicts: string[];
+    version: number;
+}
+/**
+ * AgentDB interface (to be provided by claude-flow)
+ */
+interface IAgentDBService {
+    store(key: string, value: unknown, namespace?: string, metadata?: Record<string, unknown>): Promise<void>;
+    retrieve(key: string, namespace?: string): Promise<AgentDBEntry | null>;
+    search(query: string, namespace?: string, limit?: number): Promise<AgentDBEntry[]>;
+    list(namespace?: string, limit?: number, offset?: number): Promise<AgentDBEntry[]>;
+    delete(key: string, namespace?: string): Promise<void>;
+    getNamespaceStats(namespace: string): Promise<{
+        count: number;
+        lastUpdated?: string;
+    }>;
+}
+/**
+ * Logger interface
+ */
+interface SyncLogger {
+    debug: (msg: string, meta?: Record<string, unknown>) => void;
+    info: (msg: string, meta?: Record<string, unknown>) => void;
+    warn: (msg: string, meta?: Record<string, unknown>) => void;
+    error: (msg: string, meta?: Record<string, unknown>) => void;
+}
+/**
+ * Sync bridge error codes
+ */
+type SyncErrorCode = 'NOT_INITIALIZED' | 'SYNC_FAILED' | 'CONFLICT_UNRESOLVED' | 'AGENTDB_ERROR' | 'BEADS_ERROR' | 'VALIDATION_ERROR' | 'TRANSACTION_FAILED';
+/**
+ * Sync bridge error
+ */
+declare class SyncBridgeError extends Error {
+    readonly code: SyncErrorCode;
+    readonly details?: Record<string, unknown> | undefined;
+    readonly cause?: Error | undefined;
+    constructor(message: string, code: SyncErrorCode, details?: Record<string, unknown> | undefined, cause?: Error | undefined);
+}
+/**
+ * Beads-AgentDB Sync Bridge
+ *
+ * Provides bidirectional synchronization between Beads and AgentDB
+ * with configurable conflict resolution.
+ *
+ * @example
+ * ```typescript
+ * const syncBridge = new SyncBridge(agentDB, {
+ *   conflictStrategy: 'newest-wins',
+ *   agentdbNamespace: 'conversation-beads',
+ * });
+ * await syncBridge.initialize();
+ *
+ * // Sync beads to AgentDB
+ * const result = await syncBridge.syncToAgentDB(beads);
+ *
+ * // Sync from AgentDB back to beads
+ * const beads = await syncBridge.syncFromAgentDB();
+ * ```
+ */
+declare class SyncBridge {
+    private bdBridge;
+    private agentDB;
+    private config;
+    private logger;
+    private initialized;
+    private syncState;
+    private conflicts;
+    constructor(agentDB: IAgentDBService, config?: SyncBridgeConfig, logger?: SyncLogger);
+    /**
+     * Initialize the sync bridge
+     */
+    initialize(): Promise<void>;
+    /**
+     * Sync beads to AgentDB
+     */
+    syncToAgentDB(beads: Bead[]): Promise<SyncResult>;
+    /**
+     * Sync from AgentDB to Beads
+     */
+    syncFromAgentDB(): Promise<Bead[]>;
+    /**
+     * Perform full bidirectional sync
+     */
+    syncBidirectional(): Promise<{
+        toAgentDB: SyncResult;
+        fromAgentDB: Bead[];
+    }>;
+    /**
+     * Get pending conflicts
+     */
+    getPendingConflicts(): SyncConflict[];
+    /**
+     * Resolve a specific conflict manually
+     */
+    resolveConflictManually(beadId: string, resolution: 'beads' | 'agentdb' | 'merged', mergedData?: Partial<Bead>): Promise<void>;
+    /**
+     * Get sync state
+     */
+    getSyncState(): Readonly<SyncState>;
+    /**
+     * Get sync statistics
+     */
+    getSyncStats(): Promise<{
+        agentdbCount: number;
+        lastSyncTime: string;
+        pendingConflicts: number;
+        syncVersion: number;
+    }>;
+    /**
+     * Convert bead to AgentDB key
+     */
+    private beadToKey;
+    /**
+     * Convert bead to AgentDB value
+     */
+    private beadToAgentDBValue;
+    /**
+     * Build metadata for AgentDB entry
+     */
+    private buildMetadata;
+    /**
+     * Convert AgentDB entry to Bead
+     */
+    private agentDBToBead;
+    /**
+     * Detect if there's a conflict between bead and AgentDB entry
+     */
+    private detectConflict;
+    /**
+     * Resolve conflict based on strategy
+     */
+    private resolveConflict;
+    /**
+     * Save sync state to AgentDB
+     */
+    private saveSyncState;
+    /**
+     * Ensure bridge is initialized
+     */
+    private ensureInitialized;
+    /**
+     * Check if bridge is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Get beads bridge instance
+     */
+    getBeadsBridge(): BdBridge;
+    /**
+     * Get cache statistics for performance monitoring
+     */
+    getCacheStats(): {
+        agentDBLookupCache: {
+            entries: number;
+            sizeBytes: number;
+        };
+        conflictCache: {
+            entries: number;
+            sizeBytes: number;
+        };
+    };
+    /**
+     * Clear all sync caches
+     */
+    clearCaches(): void;
+}
+/**
+ * Create a new sync bridge instance
+ */
+declare function createSyncBridge(agentDB: IAgentDBService, config?: SyncBridgeConfig, logger?: SyncLogger): SyncBridge;
+
+export { AddressSchema, type AgentDBEntry, AgentDBEntrySchema, BdArgumentSchema, BdBridge, type BdBridgeConfig, BdBridgeError, type BdErrorCode, type BdLogger, type BdResult, type BdStreamResult, BeadIdSchema, type BeadQuery, type Bead as CliBead, BeadSchema as CliBeadSchema, type BeadType as CliBeadType, BeadTypeSchema as CliBeadTypeSchema, type SyncDirection as CliSyncDirection, SyncDirectionSchema as CliSyncDirectionSchema, type SyncResult as CliSyncResult, type ConflictStrategy, ConflictStrategySchema, type CreateBeadParams, type GasEstimate, GasLimitSchema, GasPriceSchema, GtArgumentSchema, GtBridge, type GtBridgeConfig, GtBridgeError, type GtErrorCode, IdentifierSchema as GtIdentifierSchema, type GtLogger, type GtResult, SafeStringSchema as GtSafeStringSchema, type IAgentDBService, NetworkSchema, type NetworkStatus, SyncBridge, type SyncBridgeConfig, SyncBridgeError, type SyncConflict, type SyncErrorCode, type SyncLogger, type SyncState, type SyncStatus, SyncStatusSchema, TxHashSchema, type TxStatus, createBdBridge, createGtBridge, createSyncBridge };