@weavelogic/knowledge-graph-agent 0.1.0 → 0.3.0

package/README.md

@@ -1,17 +1,18 @@
 # @weavelogic/knowledge-graph-agent
 
-A powerful NPM library for creating and managing knowledge graphs for Claude Code. Integrates with Obsidian-style documentation and claude-flow for AI coordination.
+A powerful NPM library for creating and managing knowledge graphs for Claude Code. Integrates with Obsidian-style documentation, claude-flow for AI coordination, and provides enterprise-grade features for production deployments.
 
 [![npm version](https://img.shields.io/npm/v/@weavelogic/knowledge-graph-agent.svg)](https://www.npmjs.com/package/@weavelogic/knowledge-graph-agent)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-## Features
+## Features at a Glance
 
-- **Knowledge Graph Generation** - Automatically generate knowledge graphs from markdown documentation
-- **Docs Initialization** - Create structured documentation directories following weave-nn methodology
-- **CLAUDE.md Management** - Generate and update CLAUDE.md configuration files
-- **Claude-Flow Integration** - Sync knowledge graphs with claude-flow memory for cross-session persistence
-- **Full-Text Search** - SQLite-backed search across all documentation
+| Phase | Feature Area | Description |
+|-------|--------------|-------------|
+| 1 | Cultivation System | Codebase analysis, seed generation, deep analysis |
+| 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 |
 
 ## Installation
 
@@ -27,221 +28,689 @@ npx @weavelogic/knowledge-graph-agent init
 
 ## Quick Start
 
-### 1. Initialize Knowledge Graph
-
 ```bash
-# Initialize in current project
+# Initialize knowledge graph in project
 kg init
 
-# Initialize with custom paths
-kg init --path /path/to/project --docs documentation
+# Bootstrap primitives from codebase analysis
+kg init-primitives
+
+# Generate knowledge graph
+kg graph
+
+# Start MCP server for Claude integration
+kg mcp start
 ```
 
-### 2. Initialize Documentation Directory
+---
 
-```bash
-# Create docs with weave-nn structure
-kg docs init
+## Phase 1: Cultivation System
 
-# Create minimal docs
-kg docs init --no-examples
-```
+### SeedGenerator
 
-### 3. Generate Knowledge Graph
+Analyzes codebases to bootstrap knowledge graphs with primitive nodes.
 
-```bash
-# Full generation
-kg graph
+**Supported Ecosystems:**
+- **Node.js**: `package.json` dependencies
+- **Python**: `requirements.txt`, `pyproject.toml`
+- **PHP**: `composer.json`
+- **Rust**: `Cargo.toml`
+- **Go**: `go.mod`
+- **Java**: `pom.xml`, `build.gradle`
+
+```typescript
+import { SeedGenerator, analyzeSeed, initPrimitives } from '@weavelogic/knowledge-graph-agent';
+
+// Full analysis
+const analysis = await analyzeSeed('/project', 'docs');
+console.log(`Found ${analysis.frameworks.length} frameworks`);
+console.log(`Found ${analysis.dependencies.length} dependencies`);
+console.log(`Found ${analysis.services.length} services`);
 
-# Incremental update
-kg graph --update
+// Generate primitive nodes
+const result = await initPrimitives('/project', 'docs', { dryRun: false });
+console.log(`Generated ${result.documentsGenerated.length} documents`);
 ```
 
-### 4. Update CLAUDE.md
+### DeepAnalyzer with claude-flow Integration
+
+Advanced codebase analysis using multi-agent orchestration.
 
 ```bash
-# Generate CLAUDE.md with knowledge graph integration
-kg claude update
+# Deep analysis with claude-flow agents
+kg analyze deep
 
-# Use full template with all sections
-kg claude update --template full
+# Generate analysis report
+kg analyze report --json
 ```
 
-### 5. Sync with Claude-Flow
+### Shadow Cache for File Tracking
 
-```bash
-# Sync to claude-flow memory
-kg sync
+Tracks file changes efficiently using SHA-256 hashing.
+
+```typescript
+import { ShadowCache } from '@weavelogic/knowledge-graph-agent';
 
-# Show MCP commands for manual sync
-kg sync --show-commands
+const cache = new ShadowCache('/project/.kg');
+const changed = await cache.getChangedFiles('/project/docs');
+console.log(`${changed.length} files changed since last sync`);
 ```
 
-## CLI Commands
+### CLI Commands (Phase 1)
 
 | Command | Description |
 |---------|-------------|
-| `kg init` | Initialize knowledge graph in project |
-| `kg graph` | Generate/update knowledge graph |
-| `kg docs init` | Initialize docs directory |
-| `kg docs status` | Show documentation status |
-| `kg claude update` | Update CLAUDE.md |
-| `kg claude preview` | Preview CLAUDE.md content |
-| `kg sync` | Sync with claude-flow memory |
-| `kg stats` | Display graph statistics |
-| `kg search <query>` | Search the knowledge graph |
+| `kg init-primitives` | Bootstrap primitives from codebase analysis |
+| `kg init-primitives --dry-run` | Preview without writing files |
+| `kg analyze-codebase` | Analyze dependencies and services |
+| `kg cultivate` | Run cultivation pipeline |
+| `kg cultivate --deep` | Deep analysis with agents |
 
-## Programmatic Usage
+---
+
+## Phase 2: Core Features
+
+### Agent System
+
+A comprehensive agent framework with specialized agents for different tasks.
+
+**Agent Types:**
+- `ResearcherAgent` - Research and information gathering
+- `CoderAgent` - Code generation and modification
+- `TesterAgent` - Test creation and validation
+- `AnalystAgent` - Analysis and recommendations
+- `ArchitectAgent` - System design and architecture
 
 ```typescript
 import {
-  createKnowledgeGraph,
-  createDatabase,
-  initDocs,
-  generateClaudeMd,
-  quickInit,
+  BaseAgent,
+  getRegistry,
+  AgentType,
+  createTask
 } from '@weavelogic/knowledge-graph-agent';
 
-// Quick initialization
-const result = await quickInit({
-  projectRoot: '/path/to/project',
-  docsPath: 'docs',
-  generateGraph: true,
-  updateClaudeMd: true,
+// Get the agent registry
+const registry = getRegistry();
+
+// Spawn a researcher agent
+const agent = await registry.spawn(AgentType.RESEARCHER, {
+  name: 'docs-researcher',
+  claudeFlow: { enabled: true, namespace: 'kg' },
+});
+
+// Execute a task
+const task = createTask('Research authentication patterns', {
+  priority: TaskPriority.HIGH,
+  input: { topic: 'OAuth2' },
+});
+
+const result = await agent.execute(task);
+console.log(result.data);
+```
+
+**BaseAgent Features:**
+- Task execution with timeout and retry handling
+- Input validation
+- Output formatting
+- Error handling and logging
+- Claude-flow hooks integration
+- Message passing between agents
+
+### RulesEngine for Automation
+
+Define and execute automation rules based on triggers and conditions.
+
+```typescript
+import { RulesEngine, RuleType, TriggerType } from '@weavelogic/knowledge-graph-agent';
+
+const engine = new RulesEngine();
+
+engine.registerRule({
+  id: 'auto-tag',
+  name: 'Auto-tag documentation',
+  type: RuleType.TRANSFORM,
+  trigger: { type: TriggerType.FILE_CHANGE, pattern: 'docs/**/*.md' },
+  condition: (context) => context.file.endsWith('.md'),
+  action: async (context) => { /* auto-tag logic */ },
 });
 
-// Or use individual components
-const db = createDatabase('.kg/knowledge.db');
-const graph = createKnowledgeGraph('my-project', '/project/root');
+engine.start();
+```
+
+### Workflow Registry
+
+Multi-step workflow orchestration with dependencies.
 
-// Generate docs
-await initDocs({
-  projectRoot: '/project/root',
-  docsPath: 'docs',
-  includeExamples: true,
+```typescript
+import { WorkflowRegistry } from '@weavelogic/knowledge-graph-agent';
+
+const registry = new WorkflowRegistry();
+
+registry.register({
+  id: 'documentation-sync',
+  name: 'Documentation Sync',
+  steps: [
+    { id: 'analyze', action: 'analyze-docs' },
+    { id: 'generate', action: 'generate-graph', dependsOn: ['analyze'] },
+    { id: 'sync', action: 'sync-memory', dependsOn: ['generate'] },
+  ],
 });
 
-// Generate CLAUDE.md
-const claudeContent = generateClaudeMd({
-  projectRoot: '/project/root',
-  includeKnowledgeGraph: true,
-  includeClaudeFlow: true,
+await registry.execute('documentation-sync', { projectRoot: '/project' });
+```
+
+### VaultMemorySync
+
+Synchronize knowledge graph with claude-flow memory.
+
+```typescript
+import { VaultMemorySync } from '@weavelogic/knowledge-graph-agent';
+
+const sync = new VaultMemorySync({
+  vaultPath: '/project/docs',
+  namespace: 'knowledge-graph',
 });
+
+await sync.syncAll();
 ```
 
-## Documentation Structure
+### Git Integration
+
+Automatic commit message generation and staged changes analysis.
+
+```bash
+# Show status with suggested commit message
+kg commit
+
+# Auto-commit with generated message
+kg commit -a
 
-The generated docs directory follows the weave-nn methodology:
+# Interactive commit mode
+kg commit -i
 
+# Show recent commits
+kg commit log
 ```
-docs/
-├── README.md           # Documentation home
-├── PRIMITIVES.md       # Technology primitives
-├── MOC.md              # Map of Content
-├── concepts/           # Abstract concepts
-│   ├── architecture/
-│   └── patterns/
-├── components/         # Reusable components
-│   ├── ui/
-│   └── utilities/
-├── services/           # Backend services
-│   ├── api/
-│   └── workers/
-├── features/           # Product features
-│   ├── core/
-│   └── advanced/
-├── integrations/       # External integrations
-│   ├── databases/
-│   ├── auth-providers/
-│   └── storage/
-├── standards/          # Coding standards
-│   ├── coding-standards/
-│   └── build-tools/
-├── guides/             # How-to guides
-│   ├── getting-started/
-│   └── testing/
-└── references/         # API references
-    ├── api/
-    └── cli/
+
+```typescript
+import { analyzeGitChanges, generateCommitMessage } from '@weavelogic/knowledge-graph-agent';
+
+const changes = await analyzeGitChanges('/project');
+const message = generateCommitMessage(changes);
+console.log(message);
 ```
 
-## Knowledge Graph Schema
+### MCP Server with 20+ Tools
+
+Model Context Protocol server for Claude integration.
 
-### Node Types
+```bash
+# Start MCP server
+kg mcp start
+
+# Or via npx
+npx @weavelogic/knowledge-graph-agent mcp start
+```
 
-| Type | Description |
-|------|-------------|
-| `concept` | Abstract concepts and ideas |
-| `technical` | Technical components and implementations |
-| `feature` | Product features and capabilities |
-| `primitive` | Base technology primitives |
-| `service` | Backend services and APIs |
-| `guide` | How-to guides and tutorials |
-| `standard` | Coding standards and conventions |
-| `integration` | External integrations |
+**Available MCP Tools:**
 
-### Node Frontmatter
+| Category | Tools |
+|----------|-------|
+| Graph | `kg_query`, `kg_stats`, `kg_get_node`, `kg_list_tags` |
+| Cache | `kg_cache_stats` |
+| Agents | `kg_agent_spawn`, `kg_agent_list` |
+| System | `kg_health`, `kg_health_check` |
+| Search | `kg_search_nodes`, `kg_search_tags` |
 
-```yaml
 ---
-title: My Document
-type: concept
-status: active
-tags: [concept, architecture]
-created: 2025-01-01
-updated: 2025-01-01
-aliases: [Alternative Name]
-related: [other-document]
+
+## Phase 3: Advanced Integration
+
+### ServiceManager
+
+Centralized management for background services with health monitoring.
+
+```typescript
+import { createServiceManager, ServiceHandler } from '@weavelogic/knowledge-graph-agent';
+
+const manager = createServiceManager();
+
+// Register a service
+await manager.register(
+  {
+    id: 'file-watcher',
+    name: 'File Watcher',
+    type: 'watcher',
+    autoStart: true,
+    healthCheckInterval: 60000,
+    restartOnFailure: true,
+    maxRestarts: 3,
+  },
+  myWatcherService
+);
+
+// Listen for events
+manager.on('started', (state) => console.log(`${state.name} started`));
+manager.on('healthCheck', ({ id, healthy }) => console.log(`${id}: ${healthy}`));
+
+// Graceful shutdown
+process.on('SIGTERM', () => manager.shutdown());
+```
+
+### ConfigManager with Migrations
+
+Configuration management with version migrations and validation.
+
+```typescript
+import { createConfigManager } from '@weavelogic/knowledge-graph-agent';
+
+const config = createConfigManager('/project');
+
+// Get configuration
+const dbConfig = config.get('database');
+console.log(dbConfig.path);
+
+// Update configuration
+config.update({
+  cache: { maxSize: 2000, evictionPolicy: 'lfu' },
+});
+
+// Register and run migrations
+config.registerMigration({
+  version: '1.1.0',
+  up: (cfg) => ({ ...cfg, newField: 'value' }),
+  down: (cfg) => { const { newField, ...rest } = cfg; return rest; },
+});
+
+config.migrate('1.1.0');
+
+// Validate configuration
+const { valid, errors } = config.validate();
+```
+
+### HealthMonitor
+
+System health monitoring with alerts and history.
+
+```typescript
+import { createHealthMonitor, createMemoryCheck, createDatabaseCheck } from '@weavelogic/knowledge-graph-agent';
+
+const monitor = createHealthMonitor({ checkInterval: 30000 });
+
+// Register health checks
+monitor.registerCheck(createMemoryCheck(85)); // Alert at 85% heap usage
+monitor.registerCheck(createDatabaseCheck('/project/.kg/knowledge.db'));
+
+// Listen for alerts
+monitor.on('alert', (alert) => {
+  console.error(`[${alert.severity}] ${alert.component}: ${alert.message}`);
+});
+
+// Start monitoring
+monitor.start();
+
+// Get current health
+const health = await monitor.runAllChecks();
+console.log(`System status: ${health.status}`);
+console.log(`Uptime: ${health.uptime}ms`);
+```
+
+### DecisionTracker for Explainability
+
+Track and explain AI reasoning and decisions.
+
+```typescript
+import { createDecisionTracker } from '@weavelogic/knowledge-graph-agent';
+
+const tracker = createDecisionTracker();
+
+// Start a reasoning chain
+const chainId = tracker.startChain('Process user query');
+
+// Record decisions
+const decision = tracker.recordDecision({
+  action: 'Extract entities from query',
+  reasoning: [
+    'Query contains multiple noun phrases',
+    'NLP analysis identified 3 potential entities',
+    'Confidence scores above threshold',
+  ],
+  confidence: 'high',
+  context: {
+    trigger: 'user_query',
+    inputs: { query: 'Tell me about React and TypeScript' },
+    constraints: ['max 10 entities'],
+    alternatives: [],
+  },
+});
+
+// Record outcome
+tracker.recordOutcome(decision.id, {
+  success: true,
+  result: { entities: ['React', 'TypeScript'] },
+  duration: 150,
+  sideEffects: [],
+});
+
+// Get explanation
+console.log(tracker.explainDecision(decision.id));
+
+// End chain
+tracker.endChain(chainId);
+
+// Get statistics
+const stats = tracker.getStats();
+console.log(`Success rate: ${stats.successRate * 100}%`);
+```
+
 ---
+
+## Phase 4: Enterprise Features
+
+### Chunker for Large Documents
+
+Split large documents into manageable chunks with multiple strategies.
+
+**Strategies:**
+- `fixed` - Character-based chunking with overlap
+- `semantic` - Paragraph-based chunking
+- `markdown` - Respects markdown structure (headers, sections)
+- `code` - Preserves code blocks as atomic units
+- `adaptive` - Auto-selects best strategy based on content
+
+```typescript
+import { createChunker, chunkDocument } from '@weavelogic/knowledge-graph-agent';
+
+// Quick usage
+const result = chunkDocument(largeMarkdownContent, {
+  strategy: 'adaptive',
+  maxSize: 2000,
+  overlap: 50,
+});
+
+console.log(`Split into ${result.chunks.length} chunks`);
+console.log(`Processing time: ${result.processingTime}ms`);
+
+// With configuration
+const chunker = createChunker({
+  defaultStrategy: 'markdown',
+  defaultMaxSize: 4000,
+});
+
+const chunks = chunker.chunk(content);
+for (const chunk of chunks) {
+  console.log(`Chunk ${chunk.id}: ${chunk.metadata.wordCount} words`);
+}
 ```
 
-## Claude-Flow Integration
+### BackupManager with Compression
 
-The knowledge graph integrates with claude-flow for:
+Automatic backup with gzip compression and checksums.
 
-- **Memory Persistence**: Store graph data in claude-flow memory
-- **Cross-Session Context**: Access knowledge across Claude sessions
-- **Agent Coordination**: Share knowledge between swarm agents
+```typescript
+import { createBackupManager } from '@weavelogic/knowledge-graph-agent';
+
+const backup = createBackupManager('/project/.kg/knowledge.db', {
+  enabled: true,
+  interval: 86400000, // 24 hours
+  maxBackups: 5,
+  compress: true,
+  backupPath: '/project/.kg/backups',
+});
 
-### MCP Commands
+// Create backup
+const info = await backup.createBackup();
+console.log(`Backup created: ${info.id}`);
+console.log(`Size: ${info.size} bytes`);
+console.log(`Checksum: ${info.checksum}`);
 
-```javascript
-// Store node in memory
-mcp__claude-flow__memory_usage {
-  action: "store",
-  key: "node/<id>",
-  namespace: "knowledge-graph",
-  value: { ... }
+// List backups
+const backups = backup.listBackups();
+for (const b of backups) {
+  console.log(`${b.id}: ${b.timestamp.toISOString()}`);
 }
 
-// Retrieve node
-mcp__claude-flow__memory_usage {
-  action: "retrieve",
-  key: "node/<id>",
-  namespace: "knowledge-graph"
+// Restore from backup
+await backup.restore(backups[0].id);
+
+// Start automatic backups
+backup.startAutoBackup();
+```
+
+### IntegrityChecker for Database Validation
+
+Comprehensive database integrity checking and repair.
+
+```typescript
+import { createIntegrityChecker, checkDatabaseIntegrity } from '@weavelogic/knowledge-graph-agent';
+
+// Quick check
+const result = checkDatabaseIntegrity('/project/.kg/knowledge.db');
+console.log(`Valid: ${result.valid}`);
+console.log(`Errors: ${result.errors.length}`);
+console.log(`Warnings: ${result.warnings.length}`);
+
+// Detailed check with repair
+const checker = createIntegrityChecker('/project/.kg/knowledge.db');
+const check = checker.check();
+
+for (const table of check.tables) {
+  console.log(`${table.name}: ${table.rowCount} rows, valid: ${table.valid}`);
+  if (!table.valid) {
+    console.log(`  Issues: ${table.issues.join(', ')}`);
+  }
 }
 
-// Search nodes
-mcp__claude-flow__memory_search {
-  pattern: "node/*",
-  namespace: "knowledge-graph"
+// Repair database
+if (!check.valid) {
+  const repaired = checker.repair();
+  console.log(`Repair ${repaired ? 'successful' : 'failed'}`);
 }
+
+// Get database stats
+const stats = checker.getStats();
+console.log(`Pages: ${stats.pageCount}, Free: ${stats.freePages}`);
+console.log(`WAL mode: ${stats.walMode}`);
+```
+
+### AdvancedCache with Multiple Eviction Policies
+
+High-performance caching with LRU, LFU, FIFO, and TTL eviction.
+
+```typescript
+import { createAdvancedCache } from '@weavelogic/knowledge-graph-agent';
+
+const cache = createAdvancedCache<User>({
+  maxSize: 50 * 1024 * 1024, // 50MB
+  maxEntries: 1000,
+  defaultTTL: 300000, // 5 minutes
+  evictionPolicy: 'lru', // 'lru' | 'lfu' | 'fifo' | 'ttl'
+  onEvict: (key, value) => console.log(`Evicted: ${key}`),
+});
+
+// Basic operations
+cache.set('user:123', userData, { tags: ['user', 'active'] });
+const user = cache.get<User>('user:123');
+
+// Tag-based operations
+const activeUsers = cache.getByTag('active');
+cache.deleteByTag('user');
+
+// Get or set with factory
+const result = await cache.getOrSet('expensive:key', async () => {
+  return await expensiveComputation();
+}, { ttl: 60000 });
+
+// Statistics
+const stats = cache.getStats();
+console.log(`Hit rate: ${(stats.hitRate * 100).toFixed(1)}%`);
+console.log(`Evictions: ${stats.evictions}`);
+
+// Change policy at runtime
+cache.setEvictionPolicy('lfu');
+```
+
+### Diagnostics CLI
+
+Comprehensive troubleshooting tools.
+
+```bash
+# Run full diagnostics
+kg diag run
+
+# Attempt to fix issues
+kg diag run --fix
+
+# Check system health
+kg diag health
+
+# Repair database issues
+kg diag repair
+
+# Create database backup
+kg diag backup
+
+# List existing backups
+kg diag backup --list
+
+# Show system information
+kg diag info
 ```
 
+---
+
+## CLI Commands Reference
+
+### Initialization
+
+| Command | Description |
+|---------|-------------|
+| `kg init` | Initialize knowledge graph in project |
+| `kg init-primitives` | Bootstrap primitives from codebase |
+| `kg init-primitives --dry-run` | Preview without writing files |
+| `kg analyze-codebase` | Analyze dependencies and services |
+
+### Knowledge Graph
+
+| Command | Description |
+|---------|-------------|
+| `kg graph` | Generate/update knowledge graph |
+| `kg graph --update` | Incremental update |
+| `kg stats` | Display graph statistics |
+| `kg search <query>` | Search the knowledge graph |
+
+### Documentation
+
+| Command | Description |
+|---------|-------------|
+| `kg docs init` | Initialize docs directory |
+| `kg docs status` | Show documentation status |
+| `kg analyze` | Analyze & migrate to knowledge graph |
+| `kg analyze deep` | Deep analysis with claude-flow |
+| `kg analyze report` | Generate analysis report |
+| `kg convert docs` | Convert docs/ to docs-nn/ |
+
+### Frontmatter
+
+| Command | Description |
+|---------|-------------|
+| `kg frontmatter add` | Add frontmatter to markdown files |
+| `kg frontmatter validate` | Validate frontmatter |
+| `kg frontmatter update` | Update/regenerate frontmatter |
+
+### SOP Compliance
+
+| Command | Description |
+|---------|-------------|
+| `kg sop init` | Initialize SOP standards layer |
+| `kg sop check` | Check compliance against SOPs |
+| `kg sop gaps` | Analyze compliance gaps |
+| `kg sop report` | Generate compliance report |
+| `kg sop list` | List available SOPs |
+
+### Claude Integration
+
+| Command | Description |
+|---------|-------------|
+| `kg claude update` | Update CLAUDE.md |
+| `kg claude preview` | Preview CLAUDE.md content |
+| `kg sync` | Sync with claude-flow memory |
+
+### Git Integration
+
+| Command | Description |
+|---------|-------------|
+| `kg commit` | Show status with suggested message |
+| `kg commit -a` | Auto-commit with generated message |
+| `kg commit -i` | Interactive commit mode |
+| `kg commit -m "msg"` | Commit with custom message |
+| `kg commit status` | Show git status with analysis |
+| `kg commit log` | Show recent commits |
+| `kg commit diff` | Show diff of changes |
+
+### Configuration
+
+| Command | Description |
+|---------|-------------|
+| `kg config show` | Show current configuration |
+| `kg config set <key> <value>` | Set configuration value |
+| `kg config reset` | Reset to defaults |
+
+### Diagnostics
+
+| Command | Description |
+|---------|-------------|
+| `kg diag run` | Run full diagnostics |
+| `kg diag run --fix` | Attempt to fix issues |
+| `kg diag health` | Check system health |
+| `kg diag repair` | Repair database issues |
+| `kg diag backup` | Create database backup |
+| `kg diag backup --list` | List existing backups |
+| `kg diag info` | Show system information |
+
+---
+
 ## Configuration
 
 Create `.kg/config.json` to customize behavior:
 
 ```json
 {
+  "version": "1.0.0",
   "projectRoot": ".",
-  "docsRoot": "docs",
-  "graph": {
-    "includePatterns": ["**/*.md"],
-    "excludePatterns": ["node_modules/**", "dist/**"]
-  },
+  "docsPath": "docs",
   "database": {
-    "path": ".kg/knowledge.db"
+    "path": ".kg/knowledge.db",
+    "autoBackup": true,
+    "backupInterval": 86400000,
+    "maxBackups": 5
+  },
+  "cache": {
+    "enabled": true,
+    "maxSize": 1000,
+    "ttl": 3600000,
+    "evictionPolicy": "lru"
+  },
+  "agents": {
+    "maxConcurrent": 5,
+    "defaultTimeout": 30000,
+    "retryAttempts": 3,
+    "claudeFlowEnabled": true
+  },
+  "services": {
+    "watcherEnabled": true,
+    "schedulerEnabled": true,
+    "syncEnabled": true,
+    "healthCheckInterval": 60000
+  },
+  "logging": {
+    "level": "info",
+    "format": "text"
+  },
+  "analyzer": {
+    "targetDir": "docs-nn",
+    "createMOC": true,
+    "linkOriginal": true
   },
   "claudeFlow": {
     "enabled": true,
@@ -251,6 +720,118 @@ Create `.kg/config.json` to customize behavior:
 }
 ```
 
+---
+
+## Programmatic Usage
+
+```typescript
+import {
+  // Core
+  createKnowledgeGraph,
+  createDatabase,
+
+  // Initialization
+  quickInit,
+  initDocs,
+  generateClaudeMd,
+
+  // Analysis
+  analyzeDocs,
+  convertDocs,
+  addFrontmatter,
+  analyzeSeed,
+  initPrimitives,
+
+  // Agents
+  BaseAgent,
+  getRegistry,
+  AgentType,
+  createTask,
+
+  // Services
+  createServiceManager,
+  createConfigManager,
+  createHealthMonitor,
+
+  // Enterprise
+  createChunker,
+  createBackupManager,
+  createIntegrityChecker,
+  createAdvancedCache,
+
+  // Reasoning
+  createDecisionTracker,
+
+  // Types
+  type KGConfiguration,
+  type AgentConfig,
+  type ChunkOptions,
+} from '@weavelogic/knowledge-graph-agent';
+```
+
+---
+
+## Changelog
+
+### v0.4.0 (Phase 4 - Enterprise Features)
+
+- **NEW**: `Chunker` with 5 chunking strategies (fixed, semantic, markdown, code, adaptive)
+- **NEW**: `BackupManager` with gzip compression and SHA-256 checksums
+- **NEW**: `IntegrityChecker` for database validation and repair
+- **NEW**: `AdvancedCache` with LRU/LFU/FIFO/TTL eviction policies
+- **NEW**: `kg diag` CLI commands for diagnostics and troubleshooting
+- **NEW**: Tag-based cache operations
+- **NEW**: Automatic backup scheduling
+
+### v0.3.0 (Phase 3 - Advanced Integration)
+
+- **NEW**: `ServiceManager` for background process management
+- **NEW**: `ConfigManager` with migration support and validation
+- **NEW**: `HealthMonitor` with component health checks and alerts
+- **NEW**: `DecisionTracker` for AI reasoning explainability
+- **NEW**: `kg config` CLI commands
+- **IMPROVED**: Health check history and performance metrics
+
+### v0.2.0 (Phase 2 - Core Features)
+
+- **NEW**: Agent system with BaseAgent and specialized agents
+- **NEW**: `RulesEngine` for automation
+- **NEW**: `WorkflowRegistry` for multi-step workflows
+- **NEW**: `VaultMemorySync` for memory synchronization
+- **NEW**: Git integration with auto-commit
+- **NEW**: MCP Server with 20+ tools
+- **NEW**: `kg commit` CLI commands
+
+### v0.1.0 (Phase 1 - Cultivation System)
+
+- **NEW**: `SeedGenerator` for codebase analysis
+- **NEW**: `DeepAnalyzer` with claude-flow integration
+- **NEW**: `init-primitives` and `cultivate` CLI commands
+- **NEW**: Shadow Cache for file change tracking
+- Initial knowledge graph generation
+- Docs initialization
+- CLAUDE.md management
+- Full-text search
+
+---
+
+## Roadmap
+
+### 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
+
+- None currently
+
+---
+
 ## API Reference
 
 See [docs/API.md](./docs/API.md) for detailed API documentation.