@kiyeonjeon21/datacontext 0.3.2 → 0.4.0

package/scripts/test-databases.sh

@@ -0,0 +1,324 @@
+#!/bin/bash
+# Test Databases Setup Script
+# Uses Podman to run PostgreSQL, MySQL, and MariaDB for testing
+
+set -e
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+echo -e "${GREEN}=== DataContext Database Test Environment ===${NC}"
+
+# Check if podman is available
+if ! command -v podman &> /dev/null; then
+    echo -e "${RED}Error: podman is not installed${NC}"
+    echo "Install with: brew install podman"
+    exit 1
+fi
+
+# Configuration
+POSTGRES_PORT=5433
+MYSQL_PORT=3307
+MARIADB_PORT=3308
+NETWORK_NAME="datacontext-test"
+
+# Create network if not exists
+podman network exists $NETWORK_NAME 2>/dev/null || podman network create $NETWORK_NAME
+
+# Function to start PostgreSQL
+start_postgres() {
+    echo -e "\n${YELLOW}Starting PostgreSQL...${NC}"
+    
+    # Stop if running
+    podman rm -f datacontext-postgres 2>/dev/null || true
+    
+    podman run -d \
+        --name datacontext-postgres \
+        --network $NETWORK_NAME \
+        -e POSTGRES_USER=postgres \
+        -e POSTGRES_PASSWORD=postgres \
+        -e POSTGRES_DB=datacontext_test \
+        -p $POSTGRES_PORT:5432 \
+        postgres:15-alpine
+    
+    echo -e "${GREEN}PostgreSQL started on port $POSTGRES_PORT${NC}"
+    echo "Connection: postgres://postgres:postgres@localhost:$POSTGRES_PORT/datacontext_test"
+}
+
+# Function to start MySQL
+start_mysql() {
+    echo -e "\n${YELLOW}Starting MySQL...${NC}"
+    
+    # Stop if running
+    podman rm -f datacontext-mysql 2>/dev/null || true
+    
+    podman run -d \
+        --name datacontext-mysql \
+        --network $NETWORK_NAME \
+        -e MYSQL_ROOT_PASSWORD=mysql \
+        -e MYSQL_DATABASE=datacontext_test \
+        -e MYSQL_USER=mysql \
+        -e MYSQL_PASSWORD=mysql \
+        -p $MYSQL_PORT:3306 \
+        mysql:8.0
+    
+    echo -e "${GREEN}MySQL started on port $MYSQL_PORT${NC}"
+    echo "Connection: mysql://mysql:mysql@localhost:$MYSQL_PORT/datacontext_test"
+}
+
+# Function to start MariaDB
+start_mariadb() {
+    echo -e "\n${YELLOW}Starting MariaDB...${NC}"
+    
+    # Stop if running
+    podman rm -f datacontext-mariadb 2>/dev/null || true
+    
+    podman run -d \
+        --name datacontext-mariadb \
+        --network $NETWORK_NAME \
+        -e MARIADB_ROOT_PASSWORD=mariadb \
+        -e MARIADB_DATABASE=datacontext_test \
+        -e MARIADB_USER=mariadb \
+        -e MARIADB_PASSWORD=mariadb \
+        -p $MARIADB_PORT:3306 \
+        mariadb:10.11
+    
+    echo -e "${GREEN}MariaDB started on port $MARIADB_PORT${NC}"
+    echo "Connection: mysql://mariadb:mariadb@localhost:$MARIADB_PORT/datacontext_test"
+}
+
+# Function to wait for DB
+wait_for_db() {
+    local name=$1
+    local port=$2
+    local max_attempts=30
+    local attempt=0
+    
+    echo -e "${YELLOW}Waiting for $name to be ready...${NC}"
+    
+    while [ $attempt -lt $max_attempts ]; do
+        if podman exec $name echo "SELECT 1" 2>/dev/null; then
+            echo -e "${GREEN}$name is ready!${NC}"
+            return 0
+        fi
+        attempt=$((attempt + 1))
+        sleep 1
+    done
+    
+    echo -e "${RED}$name failed to start${NC}"
+    return 1
+}
+
+# Function to create test data
+create_test_data() {
+    local db_type=$1
+    local container=$2
+    
+    echo -e "\n${YELLOW}Creating test data for $db_type...${NC}"
+    
+    case $db_type in
+        postgres)
+            podman exec -i $container psql -U postgres -d datacontext_test << 'EOF'
+-- Users table
+CREATE TABLE IF NOT EXISTS users (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(100) NOT NULL,
+    email VARCHAR(255) UNIQUE NOT NULL,
+    status INTEGER DEFAULT 1,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP
+);
+
+COMMENT ON TABLE users IS 'User accounts table';
+COMMENT ON COLUMN users.status IS 'Account status: 0=inactive, 1=active, 2=suspended';
+
+-- Products table
+CREATE TABLE IF NOT EXISTS products (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(200) NOT NULL,
+    price DECIMAL(10,2) NOT NULL,
+    inventory INTEGER DEFAULT 0,
+    category VARCHAR(50),
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+COMMENT ON TABLE products IS 'Product catalog';
+
+-- Orders table
+CREATE TABLE IF NOT EXISTS orders (
+    id SERIAL PRIMARY KEY,
+    user_id INTEGER REFERENCES users(id),
+    product_id INTEGER REFERENCES products(id),
+    quantity INTEGER NOT NULL,
+    total_amount DECIMAL(10,2) NOT NULL,
+    status VARCHAR(20) DEFAULT 'pending',
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+COMMENT ON TABLE orders IS 'Customer orders';
+COMMENT ON COLUMN orders.status IS 'Order status: pending, paid, shipped, delivered, cancelled';
+
+-- Insert sample data
+INSERT INTO users (name, email, status) VALUES
+    ('Alice', 'alice@example.com', 1),
+    ('Bob', 'bob@example.com', 1),
+    ('Charlie', 'charlie@example.com', 0),
+    ('Diana', 'diana@example.com', 2)
+ON CONFLICT DO NOTHING;
+
+INSERT INTO products (name, price, inventory, category) VALUES
+    ('Laptop', 999.99, 50, 'electronics'),
+    ('Mouse', 29.99, 200, 'electronics'),
+    ('Keyboard', 79.99, 100, 'electronics'),
+    ('Desk Chair', 299.99, 30, 'furniture')
+ON CONFLICT DO NOTHING;
+
+INSERT INTO orders (user_id, product_id, quantity, total_amount, status) VALUES
+    (1, 1, 1, 999.99, 'delivered'),
+    (1, 2, 2, 59.98, 'delivered'),
+    (2, 3, 1, 79.99, 'shipped'),
+    (2, 4, 1, 299.99, 'pending')
+ON CONFLICT DO NOTHING;
+
+SELECT 'PostgreSQL test data created!' as result;
+EOF
+            ;;
+        
+        mysql)
+            sleep 10  # MySQL takes longer to start
+            podman exec -i $container mysql -umysql -pmysql datacontext_test << 'EOF'
+-- Users table
+CREATE TABLE IF NOT EXISTS users (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    name VARCHAR(100) NOT NULL,
+    email VARCHAR(255) UNIQUE NOT NULL,
+    status INT DEFAULT 1,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP NULL
+) COMMENT='User accounts table';
+
+-- Products table  
+CREATE TABLE IF NOT EXISTS products (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    name VARCHAR(200) NOT NULL,
+    price DECIMAL(10,2) NOT NULL,
+    inventory INT DEFAULT 0,
+    category VARCHAR(50),
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+) COMMENT='Product catalog';
+
+-- Orders table
+CREATE TABLE IF NOT EXISTS orders (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    user_id INT,
+    product_id INT,
+    quantity INT NOT NULL,
+    total_amount DECIMAL(10,2) NOT NULL,
+    status VARCHAR(20) DEFAULT 'pending',
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (user_id) REFERENCES users(id),
+    FOREIGN KEY (product_id) REFERENCES products(id)
+) COMMENT='Customer orders';
+
+-- Insert sample data
+INSERT IGNORE INTO users (name, email, status) VALUES
+    ('Alice', 'alice@example.com', 1),
+    ('Bob', 'bob@example.com', 1),
+    ('Charlie', 'charlie@example.com', 0),
+    ('Diana', 'diana@example.com', 2);
+
+INSERT IGNORE INTO products (name, price, inventory, category) VALUES
+    ('Laptop', 999.99, 50, 'electronics'),
+    ('Mouse', 29.99, 200, 'electronics'),
+    ('Keyboard', 79.99, 100, 'electronics'),
+    ('Desk Chair', 299.99, 30, 'furniture');
+
+INSERT IGNORE INTO orders (user_id, product_id, quantity, total_amount, status) VALUES
+    (1, 1, 1, 999.99, 'delivered'),
+    (1, 2, 2, 59.98, 'delivered'),
+    (2, 3, 1, 79.99, 'shipped'),
+    (2, 4, 1, 299.99, 'pending');
+
+SELECT 'MySQL test data created!' as result;
+EOF
+            ;;
+    esac
+    
+    echo -e "${GREEN}Test data created for $db_type${NC}"
+}
+
+# Function to stop all
+stop_all() {
+    echo -e "\n${YELLOW}Stopping all test databases...${NC}"
+    podman rm -f datacontext-postgres datacontext-mysql datacontext-mariadb 2>/dev/null || true
+    echo -e "${GREEN}All databases stopped${NC}"
+}
+
+# Function to show status
+show_status() {
+    echo -e "\n${GREEN}=== Database Status ===${NC}"
+    podman ps --filter "name=datacontext-" --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
+}
+
+# Function to show connection strings
+show_connections() {
+    echo -e "\n${GREEN}=== Connection Strings ===${NC}"
+    echo ""
+    echo -e "${YELLOW}PostgreSQL:${NC}"
+    echo "  postgres://postgres:postgres@localhost:$POSTGRES_PORT/datacontext_test"
+    echo ""
+    echo -e "${YELLOW}MySQL:${NC}"
+    echo "  mysql://mysql:mysql@localhost:$MYSQL_PORT/datacontext_test"
+    echo ""
+    echo -e "${YELLOW}MariaDB:${NC}"
+    echo "  mysql://mariadb:mariadb@localhost:$MARIADB_PORT/datacontext_test"
+    echo ""
+    echo -e "${GREEN}=== DataContext Commands ===${NC}"
+    echo ""
+    echo "# Start servers"
+    echo "npx @kiyeonjeon21/datacontext serve postgres://postgres:postgres@localhost:$POSTGRES_PORT/datacontext_test --port 3000"
+    echo "npx @kiyeonjeon21/datacontext serve mysql://mysql:mysql@localhost:$MYSQL_PORT/datacontext_test --port 3001"
+    echo ""
+}
+
+# Parse arguments
+case "${1:-start}" in
+    start)
+        start_postgres
+        start_mysql
+        sleep 15  # Wait for DBs to be ready
+        create_test_data postgres datacontext-postgres
+        create_test_data mysql datacontext-mysql
+        show_status
+        show_connections
+        ;;
+    postgres)
+        start_postgres
+        sleep 5
+        create_test_data postgres datacontext-postgres
+        show_connections
+        ;;
+    mysql)
+        start_mysql
+        sleep 15
+        create_test_data mysql datacontext-mysql
+        show_connections
+        ;;
+    stop)
+        stop_all
+        ;;
+    status)
+        show_status
+        show_connections
+        ;;
+    *)
+        echo "Usage: $0 {start|postgres|mysql|stop|status}"
+        exit 1
+        ;;
+esac
+
+echo -e "\n${GREEN}Done!${NC}"
+

package/src/adapters/sqlite.ts

@@ -11,6 +11,8 @@
  */
 
 import Database from 'better-sqlite3';
+import { existsSync, mkdirSync } from 'fs';
+import { dirname, resolve } from 'path';
 import type { DatabaseAdapter, QueryResult, ConnectionConfig } from './base.js';
 import type { SchemaInfo, TableInfo, ColumnInfo, IndexInfo, ForeignKeyInfo } from '../schema/types.js';
 import { hashSchema } from '../knowledge/schema-hash.js';
@@ -41,6 +43,20 @@ export class SQLiteAdapter implements DatabaseAdapter {
     }
 
     try {
+      // Resolve relative paths to absolute
+      let resolvedPath = this.filePath;
+      if (this.filePath !== ':memory:') {
+        resolvedPath = resolve(process.cwd(), this.filePath);
+        
+        // Ensure parent directory exists
+        const dir = dirname(resolvedPath);
+        if (!existsSync(dir)) {
+          mkdirSync(dir, { recursive: true });
+        }
+        
+        this.filePath = resolvedPath;
+      }
+      
       this.db = new Database(this.filePath, { readonly: false });
       // Enable foreign keys
       this.db.pragma('foreign_keys = ON');

package/src/api/server.ts

@@ -6,6 +6,39 @@
 import express, { Request, Response, NextFunction } from 'express';
 import cors from 'cors';
 import type { DataContextService } from '../core/context-service.js';
+import type { TableRelationship } from '../knowledge/types.js';
+
+/**
+ * Format join path response for API
+ */
+function formatPathResponse(
+  fromTable: string,
+  toTable: string,
+  path: TableRelationship[]
+): unknown {
+  const steps = path.map((rel, idx) => ({
+    step: idx + 1,
+    from: `${rel.from.schema}.${rel.from.table}`,
+    to: `${rel.to.schema}.${rel.to.table}`,
+    joinCondition: rel.joinCondition,
+    cardinality: rel.cardinality || 'unknown',
+  }));
+
+  // Generate SQL hint
+  const sqlParts = path.map(rel => 
+    `JOIN ${rel.to.table} ON ${rel.joinCondition}`
+  );
+  const sqlHint = `FROM ${fromTable}\n${sqlParts.join('\n')}`;
+
+  return {
+    found: true,
+    from: fromTable,
+    to: toTable,
+    hops: path.length,
+    path: steps,
+    sqlHint,
+  };
+}
 
 export interface ApiServerConfig {
   /** DataContext service instance */
@@ -403,6 +436,107 @@ export function createApiServer(config: ApiServerConfig): express.Application {
     }
   });
 
+  // ============================================================
+  // Knowledge Graph Endpoints
+  // ============================================================
+
+  /**
+   * Get all relationships from Knowledge Graph
+   * GET /api/relationships?table=orders
+   */
+  app.get('/api/relationships', (_req: Request, res: Response) => {
+    try {
+      const table = _req.query.table as string | undefined;
+      let relationships = service.getRelationships();
+
+      // Filter by table if specified
+      if (table) {
+        relationships = relationships.filter(
+          rel => rel.from.table === table || rel.to.table === table
+        );
+      }
+
+      res.json({
+        count: relationships.length,
+        relationships: relationships.map(rel => ({
+          id: rel.id,
+          from: `${rel.from.schema}.${rel.from.table}`,
+          to: `${rel.to.schema}.${rel.to.table}`,
+          type: rel.relationshipType,
+          joinCondition: rel.joinCondition,
+          cardinality: rel.cardinality,
+          isPreferred: rel.isPreferred,
+        })),
+      });
+    } catch (error) {
+      res.status(500).json({ 
+        error: error instanceof Error ? error.message : 'Failed to get relationships' 
+      });
+    }
+  });
+
+  /**
+   * Find join path between two tables
+   * GET /api/relationships/path?from=order_items&to=users&schema=public
+   */
+  app.get('/api/relationships/path', (_req: Request, res: Response) => {
+    try {
+      const fromTable = _req.query.from as string;
+      const toTable = _req.query.to as string;
+      const schema = (_req.query.schema as string) || 'public';
+
+      if (!fromTable || !toTable) {
+        res.status(400).json({ error: 'Both "from" and "to" query parameters are required' });
+        return;
+      }
+
+      const path = service.findJoinPath(fromTable, toTable, schema);
+
+      if (path.length === 0) {
+        // Try 'main' schema for SQLite
+        const pathMain = service.findJoinPath(fromTable, toTable, 'main');
+        if (pathMain.length === 0) {
+          res.json({
+            found: false,
+            from: fromTable,
+            to: toTable,
+            path: [],
+            message: `No path found between '${fromTable}' and '${toTable}'.`,
+          });
+          return;
+        }
+        res.json(formatPathResponse(fromTable, toTable, pathMain));
+        return;
+      }
+
+      res.json(formatPathResponse(fromTable, toTable, path));
+    } catch (error) {
+      res.status(500).json({ 
+        error: error instanceof Error ? error.message : 'Failed to find join path' 
+      });
+    }
+  });
+
+  /**
+   * Get Knowledge Graph summary
+   * GET /api/graph/summary
+   */
+  app.get('/api/graph/summary', (_req: Request, res: Response) => {
+    try {
+      const summary = service.getGraphSummary();
+      res.json({
+        ...summary,
+        message: summary.edgeCount > 0
+          ? `Knowledge Graph has ${summary.edgeCount} relationships connecting ${summary.tablesWithRelationships} tables.`
+          : 'Knowledge Graph is empty. Run POST /api/harvest to discover relationships.',
+      });
+    } catch (error) {
+      res.status(500).json({ 
+        error: error instanceof Error ? error.message : 'Failed to get graph summary' 
+      });
+    }
+  });
+
   // ============================================================
   // Glossary (Business Terms) Endpoints
   // ============================================================

package/src/cli/index.ts

@@ -34,9 +34,14 @@ function createAdapter(connectionString: string): DatabaseAdapter {
     return createPostgresAdapter(connectionString);
   } else if (url.startsWith('mysql://') || url.startsWith('mariadb://')) {
     return createMySQLAdapter(connectionString);
-  } else if (url.startsWith('sqlite://') || url.endsWith('.sqlite') || url.endsWith('.sqlite3') || url.endsWith('.db') || url === ':memory:') {
-    // SQLite: sqlite://path/to/db.sqlite or ./mydb.sqlite or :memory:
-    const filePath = url.startsWith('sqlite://') ? url.replace('sqlite://', '') : connectionString;
+  } else if (url.startsWith('sqlite://') || url.startsWith('sqlite:') || url.endsWith('.sqlite') || url.endsWith('.sqlite3') || url.endsWith('.db') || url === ':memory:') {
+    // SQLite: sqlite://path or sqlite:path or ./mydb.sqlite or :memory:
+    let filePath = connectionString;
+    if (url.startsWith('sqlite://')) {
+      filePath = connectionString.replace(/^sqlite:\/\//i, '');
+    } else if (url.startsWith('sqlite:')) {
+      filePath = connectionString.replace(/^sqlite:/i, '');
+    }
     return createSQLiteAdapter(filePath);
   } else {
     throw new Error(
@@ -65,20 +70,37 @@ program
   .option('--allowed-tables <tables...>', 'Only allow access to these tables')
   .action(async (connectionString: string, options) => {
     try {
-      // Parse connection string
-      const config = parseConnectionString(connectionString);
-      
       // Create adapter (auto-detect database type)
       const adapter = createAdapter(connectionString);
       await adapter.connect();
 
+      // Determine database ID for knowledge store
+      let databaseId: string;
+      const url = connectionString.toLowerCase();
+      
+      if (url.startsWith('sqlite://') || url.startsWith('sqlite:') || url.endsWith('.sqlite') || url.endsWith('.sqlite3') || url.endsWith('.db') || url === ':memory:') {
+        // SQLite: use filename as database ID
+        let filePath = connectionString;
+        if (url.startsWith('sqlite://')) {
+          filePath = connectionString.replace(/^sqlite:\/\//i, '');
+        } else if (url.startsWith('sqlite:')) {
+          filePath = connectionString.replace(/^sqlite:/i, '');
+        }
+        const fileName = filePath.split('/').pop() || 'sqlite';
+        databaseId = `sqlite_${fileName.replace(/[^a-zA-Z0-9]/g, '_')}`;
+      } else {
+        // URL-based databases (postgres, mysql)
+        const config = parseConnectionString(connectionString);
+        databaseId = `${config.host}_${config.database}`;
+      }
+
       // Create knowledge store
-      const databaseId = `${config.host}_${config.database}`;
       const knowledge = createKnowledgeStore(databaseId);
       await knowledge.load();
 
-      // Update schema hash
-      const schema = await adapter.getSchema(options.schema);
+      // Update schema hash (SQLite uses 'main' schema)
+      const schemaName = url.startsWith('sqlite') || url.endsWith('.db') ? 'main' : options.schema;
+      const schema = await adapter.getSchema(schemaName);
       knowledge.updateSchemaHash(schema.schemaHash);
       await knowledge.save();
 
@@ -836,21 +858,40 @@ program
     try {
       console.log('[datacontext] Starting REST API server...');
       
-      // Parse connection string
-      const config = parseConnectionString(connectionString);
-      
       // Create adapter (auto-detect database type)
       const adapter = createAdapter(connectionString);
       await adapter.connect();
-      console.log(`[datacontext] Connected to ${config.database}`);
+      
+      // Determine database ID for knowledge store
+      let databaseId: string;
+      const url = connectionString.toLowerCase();
+      
+      if (url.startsWith('sqlite://') || url.startsWith('sqlite:') || url.endsWith('.sqlite') || url.endsWith('.sqlite3') || url.endsWith('.db') || url === ':memory:') {
+        // SQLite: use filename as database ID
+        let filePath = connectionString;
+        if (url.startsWith('sqlite://')) {
+          filePath = connectionString.replace(/^sqlite:\/\//i, '');
+        } else if (url.startsWith('sqlite:')) {
+          filePath = connectionString.replace(/^sqlite:/i, '');
+        }
+        const fileName = filePath.split('/').pop() || 'sqlite';
+        databaseId = `sqlite_${fileName.replace(/[^a-zA-Z0-9]/g, '_')}`;
+        console.log(`[datacontext] Connected to SQLite: ${filePath}`);
+      } else {
+        // URL-based databases (postgres, mysql)
+        const config = parseConnectionString(connectionString);
+        databaseId = `${config.host}_${config.database}`;
+        console.log(`[datacontext] Connected to ${config.database}`);
+      }
 
       // Create knowledge store
-      const databaseId = `${config.host}_${config.database}`;
       const knowledge = createKnowledgeStore(databaseId);
       await knowledge.load();
 
-      // Update schema hash
-      const schema = await adapter.getSchema(options.schema);
+      // Update schema hash (SQLite uses 'main' schema)
+      const isSqlite = url.startsWith('sqlite') || url.endsWith('.db') || url.endsWith('.sqlite') || url.endsWith('.sqlite3');
+      const schemaName = isSqlite ? 'main' : options.schema;
+      const schema = await adapter.getSchema(schemaName);
       knowledge.updateSchemaHash(schema.schemaHash);
       await knowledge.save();
 

package/src/core/context-service.ts

@@ -577,6 +577,76 @@ export class DataContextService {
     return this.harvester.getSummary(schema);
   }
 
+  // ============================================================
+  // Knowledge Graph
+  // ============================================================
+
+  /**
+   * Get all relationships from the Knowledge Graph.
+   * 
+   * Returns table relationships (foreign keys, joins) that have been
+   * discovered through harvesting or manually defined.
+   * 
+   * @returns Array of table relationships
+   * 
+   * @example
+   * ```typescript
+   * const relationships = service.getRelationships();
+   * for (const rel of relationships) {
+   *   console.log(`${rel.from.table} → ${rel.to.table}: ${rel.joinCondition}`);
+   * }
+   * ```
+   */
+  getRelationships() {
+    return this.knowledge.getRelationships();
+  }
+
+  /**
+   * Find the optimal join path between two tables.
+   * 
+   * Uses BFS traversal of the Knowledge Graph to find the shortest
+   * path between tables. Useful for generating JOIN conditions.
+   * 
+   * @param fromTable - Source table name
+   * @param toTable - Destination table name
+   * @param schema - Schema name (defaults to 'public')
+   * @returns Array of relationships forming the path, empty if no path exists
+   * 
+   * @example
+   * ```typescript
+   * // Find path from order_items to users
+   * const path = service.findJoinPath('order_items', 'users', 'public');
+   * // Returns: [
+   * //   { from: order_items, to: orders, join: order_items.order_id = orders.id },
+   * //   { from: orders, to: users, join: orders.user_id = users.id }
+   * // ]
+   * 
+   * // Generate SQL
+   * const joins = path.map(r => `JOIN ${r.to.table} ON ${r.joinCondition}`).join('\n');
+   * ```
+   */
+  findJoinPath(fromTable: string, toTable: string, schema: string = 'public') {
+    return this.knowledge.findJoinPath(fromTable, toTable, schema);
+  }
+
+  /**
+   * Get Knowledge Graph summary statistics.
+   * 
+   * Returns information about the graph structure including
+   * node counts, edge counts, and connectivity.
+   * 
+   * @returns Graph summary object
+   * 
+   * @example
+   * ```typescript
+   * const summary = service.getGraphSummary();
+   * console.log(`Nodes: ${summary.nodeCount}, Edges: ${summary.edgeCount}`);
+   * ```
+   */
+  getGraphSummary() {
+    return this.knowledge.getGraphSummary();
+  }
+
   // ============================================================
   // Feedback & Learning
   // ============================================================