@weavelogic/knowledge-graph-agent 0.3.0 → 0.4.0

package/README.md

@@ -13,6 +13,7 @@ A powerful NPM library for creating and managing knowledge graphs for Claude Cod
 | 2 | Core Features | Agent system, rules engine, workflows, MCP server |
 | 3 | Advanced Integration | Service management, config migrations, health monitoring |
 | 4 | Enterprise Features | Chunking, backup/recovery, advanced caching, diagnostics |
+| 5 | External Integrations | Workflow DevKit, RuVector semantic search, Exochain audit trail |
 
 ## Installation
 
@@ -240,7 +241,7 @@ const message = generateCommitMessage(changes);
 console.log(message);
 ```
 
-### MCP Server with 20+ Tools
+### MCP Server with 30+ Tools
 
 Model Context Protocol server for Claude integration.
 
@@ -261,6 +262,11 @@ npx @weavelogic/knowledge-graph-agent mcp start
 | Agents | `kg_agent_spawn`, `kg_agent_list` |
 | System | `kg_health`, `kg_health_check` |
 | Search | `kg_search_nodes`, `kg_search_tags` |
+| Workflow | `kg_workflow_start`, `kg_workflow_status`, `kg_workflow_list` |
+| Vector | `kg_vector_search`, `kg_vector_upsert` |
+| Trajectory | `kg_trajectory_list` |
+| Audit | `kg_audit_query`, `kg_audit_checkpoint` |
+| Sync | `kg_sync_status` |
 
 ---
 
@@ -579,6 +585,201 @@ kg diag info
 
 ---
 
+## Phase 5: External Integrations
+
+### Workflow DevKit Integration (useworkflow.dev)
+
+Integration with the Workflow DevKit for durable workflow orchestration with Postgres persistence.
+
+**Key Concepts:**
+- **Postgres World**: Durable state persistence with transactional guarantees
+- **"use workflow" / "use step" directives**: Declarative workflow definition
+- **DurableAgent**: Agents that survive restarts and can resume from any step
+- **GOAP Planning**: Goal-Oriented Action Planning for intelligent task decomposition
+
+```typescript
+import { WorkflowManager } from '@weavelogic/knowledge-graph-agent';
+
+const workflow = new WorkflowManager({
+  postgres: process.env.DATABASE_URL,
+  durableAgents: true,
+});
+
+// Start a durable workflow
+const execution = await workflow.start('document-analysis', {
+  input: { path: '/docs' },
+  resumable: true,
+});
+
+// Check workflow status
+const status = await workflow.getStatus(execution.id);
+console.log(`Step ${status.currentStep}/${status.totalSteps}: ${status.state}`);
+
+// List active workflows
+const active = await workflow.list({ status: 'running' });
+```
+
+**CLI Commands:**
+
+| Command | Description |
+|---------|-------------|
+| `kg workflow start <name>` | Start a named workflow |
+| `kg workflow status <id>` | Get workflow execution status |
+| `kg workflow list` | List active workflow executions |
+| `kg workflow resume <id>` | Resume a paused workflow |
+| `kg workflow cancel <id>` | Cancel a running workflow |
+| `kg workflow history <name>` | Show workflow execution history |
+| `kg workflow steps <name>` | List steps in a workflow definition |
+
+**MCP Tools:**
+- `kg_workflow_start` - Start a workflow execution
+- `kg_workflow_status` - Get execution status and progress
+- `kg_workflow_list` - List workflows with filtering
+
+---
+
+### RuVector Integration
+
+High-performance semantic vector search with HNSW indexing and trajectory tracking for self-learning agents.
+
+**Key Features:**
+- **HNSW Approximate Nearest Neighbor**: Sub-millisecond search on millions of vectors
+- **Hybrid Search**: Combines vector similarity with keyword matching
+- **Trajectory Tracking**: Records decision paths for experience replay
+- **Self-Learning**: Agents improve through trajectory analysis
+
+```typescript
+import { VectorStore, TrajectoryTracker } from '@weavelogic/knowledge-graph-agent';
+
+// Initialize vector store
+const vectors = new VectorStore({
+  dimensions: 1536,
+  metric: 'cosine',
+  hnswConfig: { m: 16, efConstruction: 200 },
+});
+
+// Upsert vectors with metadata
+await vectors.upsert([
+  { id: 'doc-1', values: embedding, metadata: { type: 'concept', tags: ['api'] } },
+]);
+
+// Semantic search
+const results = await vectors.search(queryEmbedding, {
+  topK: 10,
+  filter: { type: 'concept' },
+  includeMetadata: true,
+});
+
+// Hybrid search (vector + keyword)
+const hybridResults = await vectors.hybridSearch({
+  vector: queryEmbedding,
+  keywords: ['authentication', 'oauth'],
+  alpha: 0.7, // Weight: 70% vector, 30% keyword
+});
+
+// Trajectory tracking for self-learning
+const tracker = new TrajectoryTracker();
+tracker.recordStep({
+  state: { context: 'user-query' },
+  action: 'search-knowledge-graph',
+  reward: 0.8,
+  nextState: { context: 'results-found' },
+});
+
+const trajectories = tracker.list({ minReward: 0.7 });
+```
+
+**CLI Commands:**
+
+| Command | Description |
+|---------|-------------|
+| `kg vector search <query>` | Semantic search across knowledge graph |
+| `kg vector upsert <file>` | Add/update vectors from file |
+| `kg vector delete <ids>` | Delete vectors by ID |
+| `kg vector stats` | Show vector index statistics |
+| `kg trajectory list` | List recorded trajectories |
+| `kg trajectory analyze` | Analyze trajectory patterns |
+| `kg trajectory export` | Export trajectories for training |
+| `kg trajectory prune` | Remove low-value trajectories |
+
+**MCP Tools:**
+- `kg_vector_search` - Semantic search with filters
+- `kg_vector_upsert` - Add or update vectors
+- `kg_trajectory_list` - List agent trajectories
+
+---
+
+### Exochain Integration
+
+Cryptographically verifiable audit trail with DAG-BFT consensus for distributed knowledge graph operations.
+
+**Key Features:**
+- **DAG-BFT Consensus**: Byzantine Fault Tolerant ordering without leader
+- **Hybrid Logical Clocks (HLC)**: Causally consistent timestamps
+- **BLAKE3 Hashing**: Fast cryptographic content addressing
+- **Ed25519 Signatures**: Agent-signed operations
+- **Syndication**: Replicate audit logs across nodes
+
+```typescript
+import { AuditTrail, SyncManager } from '@weavelogic/knowledge-graph-agent';
+
+// Initialize audit trail
+const audit = new AuditTrail({
+  signingKey: process.env.AGENT_PRIVATE_KEY,
+  hlcEnabled: true,
+  dagBftQuorum: 3,
+});
+
+// Record an audited operation
+const checkpoint = await audit.checkpoint({
+  operation: 'node_created',
+  nodeId: 'concept-123',
+  agent: 'coder-agent',
+  data: { title: 'Authentication Flow' },
+});
+
+console.log(`Checkpoint: ${checkpoint.hash}`);
+console.log(`HLC: ${checkpoint.hlc}`);
+console.log(`Signature: ${checkpoint.signature}`);
+
+// Query audit trail
+const history = await audit.query({
+  nodeId: 'concept-123',
+  since: '2024-01-01',
+  operations: ['node_created', 'node_updated'],
+});
+
+// Sync with remote nodes
+const sync = new SyncManager({
+  peers: ['node1.example.com', 'node2.example.com'],
+  syndication: true,
+});
+
+const status = await sync.getStatus();
+console.log(`Synced: ${status.lastSyncedHash}`);
+console.log(`Peers: ${status.connectedPeers}/${status.totalPeers}`);
+```
+
+**CLI Commands:**
+
+| Command | Description |
+|---------|-------------|
+| `kg audit query` | Query audit trail with filters |
+| `kg audit checkpoint` | Create a manual checkpoint |
+| `kg audit verify <hash>` | Verify checkpoint integrity |
+| `kg audit export` | Export audit log |
+| `kg audit stats` | Show audit trail statistics |
+| `kg sync status` | Show synchronization status |
+| `kg sync peers` | List connected peers |
+| `kg sync force` | Force synchronization |
+
+**MCP Tools:**
+- `kg_audit_query` - Query audit trail
+- `kg_audit_checkpoint` - Create checkpoint
+- `kg_sync_status` - Get sync status
+
+---
+
 ## CLI Commands Reference
 
 ### Initialization
@@ -668,6 +869,54 @@ kg diag info
 | `kg diag backup --list` | List existing backups |
 | `kg diag info` | Show system information |
 
+### Workflow (Phase 5)
+
+| Command | Description |
+|---------|-------------|
+| `kg workflow start <name>` | Start a named workflow |
+| `kg workflow status <id>` | Get workflow execution status |
+| `kg workflow list` | List active workflow executions |
+| `kg workflow resume <id>` | Resume a paused workflow |
+| `kg workflow cancel <id>` | Cancel a running workflow |
+| `kg workflow history <name>` | Show workflow execution history |
+| `kg workflow steps <name>` | List steps in a workflow definition |
+
+### Vector Search (Phase 5)
+
+| Command | Description |
+|---------|-------------|
+| `kg vector search <query>` | Semantic search across knowledge graph |
+| `kg vector upsert <file>` | Add/update vectors from file |
+| `kg vector delete <ids>` | Delete vectors by ID |
+| `kg vector stats` | Show vector index statistics |
+
+### Trajectory (Phase 5)
+
+| Command | Description |
+|---------|-------------|
+| `kg trajectory list` | List recorded trajectories |
+| `kg trajectory analyze` | Analyze trajectory patterns |
+| `kg trajectory export` | Export trajectories for training |
+| `kg trajectory prune` | Remove low-value trajectories |
+
+### Audit Trail (Phase 5)
+
+| Command | Description |
+|---------|-------------|
+| `kg audit query` | Query audit trail with filters |
+| `kg audit checkpoint` | Create a manual checkpoint |
+| `kg audit verify <hash>` | Verify checkpoint integrity |
+| `kg audit export` | Export audit log |
+| `kg audit stats` | Show audit trail statistics |
+
+### Synchronization (Phase 5)
+
+| Command | Description |
+|---------|-------------|
+| `kg sync status` | Show synchronization status |
+| `kg sync peers` | List connected peers |
+| `kg sync force` | Force synchronization |
+
 ---
 
 ## Configuration
@@ -762,10 +1011,27 @@ import {
   // Reasoning
   createDecisionTracker,
 
+  // Phase 5 - Workflow DevKit
+  WorkflowManager,
+  DurableAgent,
+  GOAPPlanner,
+
+  // Phase 5 - RuVector
+  VectorStore,
+  TrajectoryTracker,
+
+  // Phase 5 - Exochain
+  AuditTrail,
+  SyncManager,
+
   // Types
   type KGConfiguration,
   type AgentConfig,
   type ChunkOptions,
+  type WorkflowExecution,
+  type VectorSearchResult,
+  type Trajectory,
+  type AuditCheckpoint,
 } from '@weavelogic/knowledge-graph-agent';
 ```
 
@@ -773,6 +1039,24 @@ import {
 
 ## Changelog
 
+### v0.5.0 (Phase 5 - External Integrations)
+
+- **NEW**: Workflow DevKit integration with MCP tools and CLI commands
+  - `WorkflowManager` with Postgres World persistence
+  - DurableAgent support for resumable workflows
+  - GOAP planning for intelligent task decomposition
+- **NEW**: RuVector semantic search with trajectory tracking
+  - `VectorStore` with HNSW approximate nearest neighbor search
+  - Hybrid search combining vector similarity and keyword matching
+  - `TrajectoryTracker` for self-learning agents
+- **NEW**: Exochain audit trail with DAG-BFT consensus
+  - `AuditTrail` with Hybrid Logical Clocks (HLC)
+  - BLAKE3 hashing and Ed25519 signatures
+  - `SyncManager` for peer syndication
+- **NEW**: 9 new MCP tools (`kg_workflow_start`, `kg_workflow_status`, `kg_workflow_list`, `kg_vector_search`, `kg_vector_upsert`, `kg_trajectory_list`, `kg_audit_query`, `kg_audit_checkpoint`, `kg_sync_status`)
+- **NEW**: 22 new CLI subcommands across `workflow`, `vector`, `trajectory`, `audit`, and `sync` command groups
+- **NEW**: 249 new integration tests for external integrations
+
 ### v0.4.0 (Phase 4 - Enterprise Features)
 
 - **NEW**: `Chunker` with 5 chunking strategies (fixed, semantic, markdown, code, adaptive)
@@ -817,14 +1101,17 @@ import {
 
 ## Roadmap
 
+### Completed Features
+
+- [x] Real-time collaboration support (implemented via webhook handlers in v0.5.0)
+- [x] Webhook integrations (implemented in v0.5.0)
+
 ### Planned Features
 
-- [ ] Real-time collaboration support
 - [ ] Plugin system for custom analyzers
 - [ ] GraphQL API for queries
 - [ ] Web dashboard for visualization
 - [ ] Distributed caching with Redis
-- [ ] Webhook integrations
 
 ### Deprecated Features
 

package/dist/_virtual/index10.js

@@ -1,5 +1,5 @@
-var format = {};
+var compile = {};
 export {
-  format as __exports
+  compile as __exports
 };
 //# sourceMappingURL=index10.js.map

package/dist/_virtual/index6.js

@@ -1,5 +1,5 @@
-var compile = {};
+var core = {};
 export {
-  compile as __exports
+  core as __exports
 };
 //# sourceMappingURL=index6.js.map

package/dist/_virtual/index7.js

@@ -1,5 +1,5 @@
-var core = {};
+var validation = {};
 export {
-  core as __exports
+  validation as __exports
 };
 //# sourceMappingURL=index7.js.map

package/dist/_virtual/index8.js

@@ -1,5 +1,5 @@
-var validation = {};
+var applicator = {};
 export {
-  validation as __exports
+  applicator as __exports
 };
 //# sourceMappingURL=index8.js.map

package/dist/_virtual/index9.js

@@ -1,5 +1,5 @@
-var applicator = {};
+var format = {};
 export {
-  applicator as __exports
+  format as __exports
 };
 //# sourceMappingURL=index9.js.map

package/dist/audit/config.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Exochain Audit Configuration
+ *
+ * Configuration for deterministic logging with DAG-BFT consensus.
+ * Supports multiple backends: file, postgres, and memory.
+ *
+ * @module audit/config
+ */
+/**
+ * Storage backend types for audit chain.
+ * - `file`: Local file-based storage with rotation support
+ * - `postgres`: PostgreSQL database with schema isolation
+ * - `memory`: In-memory storage for testing/development
+ */
+export type AuditBackend = 'file' | 'postgres' | 'memory';
+/**
+ * Consensus mechanism types for achieving finality.
+ * - `proof-of-learning`: Learning-based consensus for AI agents
+ * - `byzantine`: Classical BFT consensus (2f+1 validators)
+ * - `raft`: Leader-based consensus for simpler setups
+ * - `gossip`: Epidemic-style eventual consistency
+ * - `none`: No consensus, single-agent mode
+ */
+export type ConsensusType = 'proof-of-learning' | 'byzantine' | 'raft' | 'gossip' | 'none';
+/**
+ * File backend configuration options.
+ */
+export interface FileBackendConfig {
+    /** Directory for storing audit chain data */
+    dataDir: string;
+    /** Maximum file size in bytes before rotation (default: 10MB) */
+    maxFileSize?: number;
+    /** Number of events before rotating to new file */
+    rotateAfterEvents?: number;
+}
+/**
+ * PostgreSQL backend configuration options.
+ */
+export interface PostgresBackendConfig {
+    /** PostgreSQL connection string */
+    connectionString: string;
+    /** Database schema for audit tables */
+    schema: string;
+}
+/**
+ * Audit chain configuration defining storage, consensus, and syndication settings.
+ */
+export interface AuditChainConfig {
+    /** Storage backend type */
+    backend: AuditBackend;
+    /** Agent's DID (Decentralized Identifier) for event signing */
+    agentDid: string;
+    /** Ed25519 private key for signing (64-byte hex string) */
+    privateKey?: string;
+    /** Enable consensus mechanism for finality */
+    enableConsensus: boolean;
+    /** Type of consensus mechanism to use */
+    consensusType: ConsensusType;
+    /** Number of events between checkpoints */
+    checkpointInterval: number;
+    /** File backend configuration (required if backend is 'file') */
+    file?: FileBackendConfig;
+    /** PostgreSQL backend configuration (required if backend is 'postgres') */
+    postgres?: PostgresBackendConfig;
+    /** Peer endpoints for event syndication */
+    peers?: string[];
+    /** Enable automatic peer syndication */
+    enableSyndication: boolean;
+    /** Interval between syndication attempts in milliseconds */
+    syndicationInterval?: number;
+}
+/**
+ * Default checkpoint interval (every 100 events).
+ */
+export declare const DEFAULT_CHECKPOINT_INTERVAL = 100;
+/**
+ * Default syndication interval (5 minutes).
+ */
+export declare const DEFAULT_SYNDICATION_INTERVAL: number;
+/**
+ * Default maximum file size for file backend (10MB).
+ */
+export declare const DEFAULT_MAX_FILE_SIZE: number;
+/**
+ * Default number of events before file rotation.
+ */
+export declare const DEFAULT_ROTATE_AFTER_EVENTS = 10000;
+/**
+ * Create audit chain configuration from environment variables.
+ *
+ * Environment variables:
+ * - `EXOCHAIN_BACKEND`: Storage backend (file|postgres|memory)
+ * - `EXOCHAIN_AGENT_DID`: Agent's decentralized identifier
+ * - `EXOCHAIN_PRIVATE_KEY`: Ed25519 private key for signing
+ * - `EXOCHAIN_ENABLE_CONSENSUS`: Enable consensus (true|false)
+ * - `EXOCHAIN_CONSENSUS_TYPE`: Consensus mechanism type
+ * - `EXOCHAIN_CHECKPOINT_INTERVAL`: Events between checkpoints
+ * - `EXOCHAIN_ENABLE_SYNDICATION`: Enable peer syndication
+ * - `EXOCHAIN_SYNDICATION_INTERVAL`: Syndication interval in ms
+ * - `EXOCHAIN_PEER_ENDPOINTS`: Comma-separated peer URLs
+ * - `EXOCHAIN_DATA_DIR`: Data directory for file backend
+ * - `EXOCHAIN_MAX_FILE_SIZE`: Max file size for file backend
+ * - `EXOCHAIN_ROTATE_AFTER_EVENTS`: Events before file rotation
+ * - `DATABASE_URL`: PostgreSQL connection string
+ * - `EXOCHAIN_SCHEMA`: PostgreSQL schema name
+ *
+ * @returns Fully populated AuditChainConfig
+ *
+ * @example
+ * ```typescript
+ * // Set environment variables
+ * process.env.EXOCHAIN_BACKEND = 'file';
+ * process.env.EXOCHAIN_DATA_DIR = './audit-data';
+ *
+ * const config = createAuditChainConfig();
+ * ```
+ */
+export declare function createAuditChainConfig(): AuditChainConfig;
+/**
+ * Validation result for audit chain configuration.
+ */
+export interface ConfigValidationResult {
+    /** Whether the configuration is valid */
+    valid: boolean;
+    /** List of validation error messages */
+    errors: string[];
+}
+/**
+ * Validate audit chain configuration for completeness and consistency.
+ *
+ * @param config - The configuration to validate
+ * @returns Validation result with errors if invalid
+ *
+ * @example
+ * ```typescript
+ * const config = createAuditChainConfig();
+ * const result = validateAuditChainConfig(config);
+ *
+ * if (!result.valid) {
+ *   console.error('Configuration errors:', result.errors);
+ * }
+ * ```
+ */
+export declare function validateAuditChainConfig(config: AuditChainConfig): ConfigValidationResult;
+/**
+ * Default configuration created from environment variables.
+ * This is a convenience export for simple use cases.
+ */
+export declare const defaultConfig: AuditChainConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/audit/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/audit/config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,UAAU,GAAG,QAAQ,CAAC;AAE1D;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,mBAAmB,GAAG,WAAW,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE3F;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,iEAAiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mDAAmD;IACnD,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,mCAAmC;IACnC,gBAAgB,EAAE,MAAM,CAAC;IACzB,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,2BAA2B;IAC3B,OAAO,EAAE,YAAY,CAAC;IACtB,+DAA+D;IAC/D,QAAQ,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,eAAe,EAAE,OAAO,CAAC;IACzB,yCAAyC;IACzC,aAAa,EAAE,aAAa,CAAC;IAC7B,2CAA2C;IAC3C,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iEAAiE;IACjE,IAAI,CAAC,EAAE,iBAAiB,CAAC;IACzB,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,qBAAqB,CAAC;IACjC,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,wCAAwC;IACxC,iBAAiB,EAAE,OAAO,CAAC;IAC3B,4DAA4D;IAC5D,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;GAEG;AACH,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,4BAA4B,QAAgB,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,qBAAqB,QAAmB,CAAC;AAEtD;;GAEG;AACH,eAAO,MAAM,2BAA2B,QAAQ,CAAC;AAmBjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,CAgDzD;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,yCAAyC;IACzC,KAAK,EAAE,OAAO,CAAC;IACf,wCAAwC;IACxC,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,gBAAgB,GAAG,sBAAsB,CA2DzF;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,kBAA2B,CAAC"}

package/dist/audit/config.js

@@ -0,0 +1,111 @@
+const DEFAULT_CHECKPOINT_INTERVAL = 100;
+const DEFAULT_SYNDICATION_INTERVAL = 5 * 60 * 1e3;
+const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
+const DEFAULT_ROTATE_AFTER_EVENTS = 1e4;
+function generateDefaultDid() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 10);
+  return `did:exo:agent-${timestamp}${random}`;
+}
+function createAuditChainConfig() {
+  const backend = process.env.EXOCHAIN_BACKEND || "memory";
+  const baseConfig = {
+    backend,
+    agentDid: process.env.EXOCHAIN_AGENT_DID || generateDefaultDid(),
+    privateKey: process.env.EXOCHAIN_PRIVATE_KEY,
+    enableConsensus: process.env.EXOCHAIN_ENABLE_CONSENSUS === "true",
+    consensusType: process.env.EXOCHAIN_CONSENSUS_TYPE || "none",
+    checkpointInterval: parseInt(
+      process.env.EXOCHAIN_CHECKPOINT_INTERVAL || String(DEFAULT_CHECKPOINT_INTERVAL),
+      10
+    ),
+    enableSyndication: process.env.EXOCHAIN_ENABLE_SYNDICATION === "true",
+    syndicationInterval: parseInt(
+      process.env.EXOCHAIN_SYNDICATION_INTERVAL || String(DEFAULT_SYNDICATION_INTERVAL),
+      10
+    ),
+    peers: process.env.EXOCHAIN_PEER_ENDPOINTS?.split(",").filter(Boolean) || []
+  };
+  switch (backend) {
+    case "file":
+      return {
+        ...baseConfig,
+        file: {
+          dataDir: process.env.EXOCHAIN_DATA_DIR || ".exochain",
+          maxFileSize: parseInt(
+            process.env.EXOCHAIN_MAX_FILE_SIZE || String(DEFAULT_MAX_FILE_SIZE),
+            10
+          ),
+          rotateAfterEvents: parseInt(
+            process.env.EXOCHAIN_ROTATE_AFTER_EVENTS || String(DEFAULT_ROTATE_AFTER_EVENTS),
+            10
+          )
+        }
+      };
+    case "postgres":
+      return {
+        ...baseConfig,
+        postgres: {
+          connectionString: process.env.DATABASE_URL || "postgres://localhost:5432/kg_agent",
+          schema: process.env.EXOCHAIN_SCHEMA || "exochain"
+        }
+      };
+    default:
+      return baseConfig;
+  }
+}
+function validateAuditChainConfig(config) {
+  const errors = [];
+  if (!config.agentDid) {
+    errors.push("Agent DID is required");
+  } else if (!config.agentDid.startsWith("did:")) {
+    errors.push('Agent DID must be a valid DID (starting with "did:")');
+  }
+  if (config.backend === "file") {
+    if (!config.file?.dataDir) {
+      errors.push("File data directory is required for file backend");
+    }
+    if (config.file?.maxFileSize !== void 0 && config.file.maxFileSize <= 0) {
+      errors.push("Max file size must be positive");
+    }
+    if (config.file?.rotateAfterEvents !== void 0 && config.file.rotateAfterEvents <= 0) {
+      errors.push("Rotate after events must be positive");
+    }
+  }
+  if (config.backend === "postgres") {
+    if (!config.postgres?.connectionString) {
+      errors.push("PostgreSQL connection string is required for postgres backend");
+    }
+    if (!config.postgres?.schema) {
+      errors.push("PostgreSQL schema is required for postgres backend");
+    }
+  }
+  if (config.enableConsensus && config.consensusType === "none") {
+    errors.push("Consensus type must be specified when consensus is enabled");
+  }
+  if (config.enableSyndication && (!config.peers || config.peers.length === 0)) {
+    errors.push("At least one peer is required for syndication");
+  }
+  if (config.checkpointInterval <= 0) {
+    errors.push("Checkpoint interval must be positive");
+  }
+  if (config.syndicationInterval !== void 0 && config.syndicationInterval <= 0) {
+    errors.push("Syndication interval must be positive");
+  }
+  if (config.privateKey !== void 0) {
+    if (!/^[0-9a-fA-F]{128}$/.test(config.privateKey)) {
+      errors.push("Private key must be a 64-byte hex string (128 characters)");
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+createAuditChainConfig();
+export {
+  DEFAULT_CHECKPOINT_INTERVAL,
+  DEFAULT_MAX_FILE_SIZE,
+  DEFAULT_ROTATE_AFTER_EVENTS,
+  DEFAULT_SYNDICATION_INTERVAL,
+  createAuditChainConfig,
+  validateAuditChainConfig
+};
+//# sourceMappingURL=config.js.map