matimo-examples 0.1.0-alpha.7

package/postgres/postgres-langchain.ts

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+/**
+ * ============================================================================
+ * POSTGRES TOOLS - LANGCHAIN AI AGENT EXAMPLE
+ * ============================================================================
+ *
+ * PATTERN: True AI Agent with OpenAI + LangChain
+ * ─────────────────────────────────────────────────────────────────────────
+ * This is a REAL AI agent that:
+ * 1. Takes natural language user requests
+ * 2. Uses OpenAI LLM (GPT-4o-mini) to decide which Postgres tools to use
+ * 3. Generates appropriate SQL based on context
+ * 4. Executes queries autonomously
+ * 5. Processes results and responds naturally
+ *
+ * CRITICAL: Database credentials are NEVER exposed to the LLM
+ * - LLM only sees tool descriptions and results
+ * - Matimo handles all credential loading from environment variables
+ * - Tool execution is secure and isolated
+ *
+ * Use this pattern when:
+ * ✅ Building true autonomous AI agents
+ * ✅ LLM should decide which tools to use
+ * ✅ Complex workflows with LLM reasoning
+ * ✅ Multi-step agentic processes
+ * ✅ User gives high-level instructions (not SQL queries)
+ *
+ * SETUP:
+ * ─────────────────────────────────────────────────────────────────────────
+ * 1. Make sure Postgres is running (see POSTGRES_EXAMPLE_SETUP.md)
+ * 2. Create .env file with database credentials:
+ *    MATIMO_POSTGRES_HOST=localhost
+ *    MATIMO_POSTGRES_PORT=5432
+ *    MATIMO_POSTGRES_USER=matimo
+ *    MATIMO_POSTGRES_PASSWORD=development
+ *    MATIMO_POSTGRES_DB=matimo
+ *    OPENAI_API_KEY=sk-xxxxxxxxxxxxx
+ *
+ * USAGE:
+ * ─────────────────────────────────────────────────────────────────────────
+ *   pnpm postgres:langchain
+ *
+ * WHAT IT DOES:
+ * ─────────────────────────────────────────────────────────────────────────
+ * This example shows an AI agent that can:
+ * 1. Explore database tables and schema
+ * 2. Execute SELECT queries to analyze data
+ * 3. Respond naturally in conversation style
+ * 4. Multi-step reasoning without exposing credentials
+ *
+ * Example:
+ *   User: "What tables exist in matimo?"
+ *   AI Agent: "Let me query the database to see what tables are available..."
+ *   [Agent calls postgres-execute-sql tool with SELECT query]
+ *   AI Agent: "The matimo database contains these tables: ..."
+ *
+ * ============================================================================
+ */
+
+import 'dotenv/config';
+import { MatimoInstance, convertToolsToLangChain, ToolDefinition } from 'matimo';
+import { createAgent } from 'langchain';
+import { ChatOpenAI } from '@langchain/openai';
+
+/**
+ * Run AI Agent with Postgres tools
+ * The agent receives natural language requests and decides which Postgres tools to use
+ */
+async function runPostgresAIAgent() {
+  console.info('\n╔════════════════════════════════════════════════════════╗');
+  console.info('║     Postgres AI Agent - LangChain + OpenAI             ║');
+  console.info('║     True autonomous agent with LLM reasoning           ║');
+  console.info('║     Database credentials: NEVER exposed to LLM         ║');
+  console.info('╚════════════════════════════════════════════════════════╝\n');
+
+  // Check required environment variables
+  const pgConnected =
+    process.env.MATIMO_POSTGRES_HOST &&
+    process.env.MATIMO_POSTGRES_USER &&
+    process.env.MATIMO_POSTGRES_PASSWORD &&
+    process.env.MATIMO_POSTGRES_DB;
+
+  if (!pgConnected) {
+    console.error('❌ Error: Postgres connection not configured in .env');
+    console.info('   Required environment variables:');
+    console.info('     MATIMO_POSTGRES_HOST');
+    console.info('     MATIMO_POSTGRES_USER');
+    console.info('     MATIMO_POSTGRES_PASSWORD');
+    console.info('     MATIMO_POSTGRES_DB');
+    process.exit(1);
+  }
+
+  const openaiKey = process.env.OPENAI_API_KEY;
+  if (!openaiKey) {
+    console.error('❌ Error: OPENAI_API_KEY not set in .env');
+    console.info('   Set it: export OPENAI_API_KEY="sk-..."');
+    process.exit(1);
+  }
+
+  console.info(
+    `📍 Postgres: ${process.env.MATIMO_POSTGRES_DB}@${process.env.MATIMO_POSTGRES_HOST}`
+  );
+  console.info(`🤖 Using OpenAI (GPT-4o-mini) as the AI agent\n`);
+
+  try {
+    // Initialize Matimo with auto-discovery
+    console.info('🚀 Initializing Matimo...');
+    const matimo = await MatimoInstance.init({ autoDiscover: true });
+
+    // Get Postgres tools and convert to LangChain format
+    console.info('💬 Loading Postgres tools...');
+    const matimoTools = matimo.listTools();
+    const postgresTools = matimoTools.filter((t) => t.name.startsWith('postgres'));
+    console.info(`✅ Loaded ${postgresTools.length} Postgres tool(s)\n`);
+
+    // ✅ Convert Matimo tools to LangChain format using the built-in integration
+    const langchainTools = await convertToolsToLangChain(
+      postgresTools as ToolDefinition[],
+      matimo,
+      {
+        // Pass database credentials so LLM tool calls can execute securely
+        // The LLM will NEVER see these values - only Matimo tool execution will use them
+      }
+    );
+
+    // Initialize OpenAI LLM
+    console.info('🤖 Initializing OpenAI (GPT-4o-mini) LLM...');
+    const model = new ChatOpenAI({
+      modelName: 'gpt-4o-mini',
+      temperature: 0.7,
+    });
+
+    // Create agent
+    console.info('🔧 Creating agent...\n');
+    const agent = await createAgent({
+      model,
+      tools: langchainTools as any[], // Type casting for LangChain tools
+    });
+
+    // Define agent tasks (sequential - each task uses results from previous)
+    const userRequests = [
+      {
+        title: 'Step 1: Discover tables',
+        request:
+          'Get a list of all tables in the matimo database. Query the information_schema to show me all tables and their row counts.',
+      },
+      {
+        title: 'Step 2: Analyze data volume',
+        request:
+          'Now that you know which tables exist, tell me the total number of records across all tables and which tables have the most data.',
+      },
+      {
+        title: 'Step 3: Show schema for main table',
+        request:
+          'For the table with the most records, show me the column structure (column names and data types) so I understand what data is stored there.',
+      },
+    ];
+
+    console.info('🧪 Running AI Agent Tasks (Sequential Workflow)');
+    console.info('═'.repeat(60));
+
+    // Run each task through the agent sequentially
+    // Each task builds on previous results instead of making assumptions
+    for (const task of userRequests) {
+      console.info(`\n${task.title}`);
+      console.info('─'.repeat(60));
+      console.info(`👤 User: "${task.request}"\n`);
+
+      try {
+        const response = await agent.invoke({
+          messages: [
+            {
+              role: 'user',
+              content: task.request,
+            },
+          ],
+        });
+
+        // Get the last message from the agent
+        const lastMessage = response.messages[response.messages.length - 1];
+        if (lastMessage) {
+          if (typeof lastMessage.content === 'string') {
+            console.info(`🤖 Agent: ${lastMessage.content}\n`);
+          } else {
+            console.info(`🤖 Agent:`, lastMessage.content, '\n');
+          }
+        }
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.info(`⚠️  Agent error: ${errorMsg}\n`);
+      }
+    }
+
+    console.info('═'.repeat(60));
+    console.info('✨ AI Agent Examples Complete!\n');
+    console.info('Key Features:');
+    console.info('  ✅ Real LLM (OpenAI) decides which tools to use');
+    console.info('  ✅ Natural language requests, not SQL queries');
+    console.info('  ✅ LLM generates SQL based on context');
+    console.info('  ✅ Database credentials NEVER exposed to LLM');
+    console.info('  ✅ Matimo handles secure credential injection');
+    console.info('  ✅ Agentic reasoning and decision-making\n');
+  } catch (error) {
+    console.error('❌ Error:', error instanceof Error ? error.message : String(error));
+    if (error instanceof Error && error.stack) {
+      console.error('Stack:', error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+// Run the AI agent
+runPostgresAIAgent().catch(console.error);

package/postgres/postgres-with-approval.ts

@@ -0,0 +1,250 @@
+/**
+ * Postgres Tool Example with Real Database and SQL Approval Flow
+ *
+ * This example demonstrates:
+ * 1. Connecting to a real Postgres database
+ * 2. Executing non-destructive queries (SELECT)
+ * 3. Executing destructive queries with approval flow
+ * 4. Setting up approval callbacks
+ *
+ * Setup Instructions:
+ * 1. Make sure you have a Postgres instance running locally or accessible
+ * 2. Set the connection string via environment variable:
+ *    export MATIMO_POSTGRES_URL="postgresql://user:password@localhost:5432/dbname"
+ *    OR set individual components:
+ *    export MATIMO_POSTGRES_HOST="localhost"
+ *    export MATIMO_POSTGRES_PORT="5432"
+ *    export MATIMO_POSTGRES_USER="user"
+ *    export MATIMO_POSTGRES_PASSWORD="password"
+ *    export MATIMO_POSTGRES_DB="dbname"
+ *
+ * 3. Run the example:
+ *    pnpm tsx examples/tools/postgres/postgres-with-approval.ts
+ */
+
+import 'dotenv/config';
+import { MatimoInstance, getSQLApprovalManager, setSQLApprovalManager } from '@matimo/core';
+import * as path from 'path';
+import * as readline from 'readline';
+
+// Interactive approval callback with better input handling
+function createInteractiveApprovalCallback() {
+  return async (sql: string, mode: string): Promise<boolean> => {
+    // Check if stdin is a TTY (interactive terminal)
+    const isInteractive = process.stdin.isTTY;
+
+    console.info(`\n⚠️  Approval Required for ${mode.toUpperCase()} operation:`);
+    console.info(`SQL: ${sql}`);
+    console.info('');
+
+    if (!isInteractive) {
+      console.info('❌ REJECTED - Non-interactive mode (no terminal input available)');
+      console.info('');
+      console.info('To run this example interactively:');
+      console.info('  1. Run directly: pnpm postgres:approval');
+      console.info('  2. Or set MATIMO_SQL_AUTO_APPROVE=true for automated approval');
+      console.info('');
+      return false;
+    }
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true,
+    });
+
+    return new Promise((resolve) => {
+      rl.question('Do you approve? (yes/no): ', (answer) => {
+        const approved = answer.toLowerCase() === 'yes' || answer.toLowerCase() === 'y';
+        console.info(`Result: ${approved ? '✅ APPROVED' : '❌ REJECTED'}\n`);
+        rl.close();
+        resolve(approved);
+      });
+    });
+  };
+}
+
+async function main() {
+  // Check if database connection is available
+  if (
+    !process.env.MATIMO_POSTGRES_URL &&
+    (!process.env.MATIMO_POSTGRES_HOST ||
+      !process.env.MATIMO_POSTGRES_USER ||
+      !process.env.MATIMO_POSTGRES_PASSWORD ||
+      !process.env.MATIMO_POSTGRES_DB)
+  ) {
+    console.error('❌ Database connection not configured.');
+    console.error('Please set one of:');
+    console.error('  - MATIMO_POSTGRES_URL="postgresql://user:password@host:port/db"');
+    console.error(
+      '  - MATIMO_POSTGRES_HOST, MATIMO_POSTGRES_PORT, MATIMO_POSTGRES_USER, MATIMO_POSTGRES_PASSWORD, MATIMO_POSTGRES_DB'
+    );
+    process.exit(1);
+  }
+
+  // Initialize Matimo with postgres tools
+  const matimo = await MatimoInstance.init({ autoDiscover: true });
+
+  console.info('🚀 Postgres Tool Example with Approval Flow');
+  console.info('='.repeat(60));
+
+  // Configure SQL approval manager
+  const approvalManager = getSQLApprovalManager();
+  approvalManager.setApprovalCallback(createInteractiveApprovalCallback());
+
+  try {
+    // 1. List available tools
+    const tools = matimo.listTools();
+    const postgresTools = tools.filter((t) => t.name.startsWith('postgres'));
+    console.info(`\n📋 Available Postgres tools: ${postgresTools.map((t) => t.name).join(', ')}`);
+
+    // Sequential discovery workflow
+
+    // STEP 1: Discover tables (SELECT - no approval needed)
+    console.info('\n\n1️⃣  DISCOVER TABLES (Step 1/3 - No approval needed)');
+    console.info('-'.repeat(60));
+    console.info('SQL: SELECT table_name FROM information_schema.tables WHERE table_schema = $1\n');
+
+    let discoveredTables: string[] = [];
+    try {
+      const tablesResult = await matimo.execute('postgres-execute-sql', {
+        sql: `
+          SELECT table_name 
+          FROM information_schema.tables 
+          WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
+          ORDER BY table_name;
+        `,
+      });
+      if (
+        tablesResult &&
+        typeof tablesResult === 'object' &&
+        'success' in tablesResult &&
+        (tablesResult as any).success === false
+      ) {
+        throw new Error((tablesResult as any).error || 'Query failed');
+      }
+      console.info('✅ Query executed successfully (no approval needed for SELECT)');
+      if (tablesResult && typeof tablesResult === 'object' && 'rows' in tablesResult) {
+        const rows = (tablesResult as any).rows;
+        if (rows && rows.length > 0) {
+          console.info('Tables found:');
+          rows.forEach((row: any) => {
+            console.info(`   - ${row.table_name}`);
+            discoveredTables.push(row.table_name);
+          });
+        } else {
+          console.info('(No tables found in public schema)');
+        }
+      } else {
+        console.info('(No tables found in public schema)');
+      }
+    } catch (err: any) {
+      console.error('❌ Error:', err.message);
+    }
+
+    // STEP 2: Get row counts (SELECT - no approval needed)
+    console.info('\n\n2️⃣  COUNT RECORDS (Step 2/3 - No approval needed)');
+    console.info('-'.repeat(60));
+    console.info('SQL: SELECT tablename, n_live_tup FROM pg_stat_user_tables\n');
+
+    try {
+      const countsResult = await matimo.execute('postgres-execute-sql', {
+        sql: `
+          SELECT 
+            table_name,
+            (SELECT count(*) FROM information_schema.columns 
+             WHERE information_schema.columns.table_name = t.table_name) as columns
+          FROM information_schema.tables t
+          WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
+          ORDER BY table_name;
+        `,
+      });
+      if (
+        countsResult &&
+        typeof countsResult === 'object' &&
+        'success' in countsResult &&
+        (countsResult as any).success === false
+      ) {
+        throw new Error((countsResult as any).error || 'Query failed');
+      }
+      console.info('✅ Query executed successfully (no approval needed for SELECT)');
+      if (countsResult && typeof countsResult === 'object' && 'rows' in countsResult) {
+        const rows = (countsResult as any).rows;
+        if (rows && rows.length > 0) {
+          console.info('Tables found:');
+          rows.forEach((row: any) => {
+            console.info(`   - ${row.table_name} (${row.columns} columns)`);
+          });
+        } else {
+          console.info('(No tables found in public schema)');
+        }
+      } else {
+        console.info('(No tables found in public schema)');
+      }
+    } catch (err: any) {
+      console.error('❌ Error:', err.message);
+    }
+
+    // STEP 3: Try a destructive operation that requires approval
+    console.info('\n\n3️⃣  DESTRUCTIVE OPERATION (Step 3/3 - Requires approval)');
+    console.info('-'.repeat(60));
+    console.info('Attempting DELETE on first discovered table (if any)...\n');
+
+    if (discoveredTables.length > 0) {
+      const tableName = discoveredTables[0];
+      console.info(`SQL: DELETE FROM ${tableName} WHERE 1=0 (safe - matches no rows)\n`);
+
+      try {
+        // Safe DELETE that matches no rows (WHERE 1=0)
+        const deleteResult = await matimo.execute('postgres-execute-sql', {
+          sql: `DELETE FROM ${tableName} WHERE 1=0;`,
+        });
+        console.info('✅ DELETE approved and executed successfully');
+        console.info('   (0 rows deleted - safe WHERE clause)\n');
+      } catch (err: any) {
+        const errorMsg = err?.message || String(err);
+        if (
+          errorMsg.includes('not approved') ||
+          errorMsg.includes('approval') ||
+          errorMsg.includes('callback')
+        ) {
+          console.info('⚠️  DELETE was REJECTED by user');
+          console.info(
+            '   Approval is required for destructive operations (CREATE/DROP/ALTER/DELETE/UPDATE)\n'
+          );
+        } else {
+          console.error('❌ Error:', errorMsg);
+        }
+      }
+    } else {
+      console.info('⚠️  No tables found to demonstrate destructive operation');
+      console.info('   (Would require approval when attempting DELETE/UPDATE/CREATE/DROP/ALTER)\n');
+    }
+
+    // STEP 4: Show approval configuration
+    console.info('\n4️⃣  APPROVAL CONFIGURATION');
+    console.info('-'.repeat(60));
+    console.info('Current approval settings:');
+    console.info(
+      `   - MATIMO_SQL_AUTO_APPROVE=${process.env.MATIMO_SQL_AUTO_APPROVE || '(not set)'}`
+    );
+    console.info(`   - Interactive approval callback: ${approvalManager ? 'Enabled' : 'Disabled'}`);
+    console.info('\nFor CI/automated environments, set:');
+    console.info('   export MATIMO_SQL_AUTO_APPROVE=true\n');
+
+    console.info('✨ Sequential discovery with approval workflow complete!');
+    console.info('='.repeat(60));
+    console.info('Pattern: 1) Discover tables 2) Count records 3) Attempt destructive op\n');
+  } catch (err: any) {
+    console.error('\n❌ Error:', err.message);
+    if (err.code === 'ECONNREFUSED') {
+      console.error('\nDatabase connection refused. Make sure your Postgres instance is running.');
+    }
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});

package/read/read-decorator.ts

@@ -0,0 +1,107 @@
+import {
+  MatimoInstance,
+  setGlobalMatimoInstance,
+  tool,
+  getPathApprovalManager,
+} from '@matimo/core';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import readline from 'readline';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Create readline interface for interactive approval prompts
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+let isReadlineClosed = false;
+
+// Track when readline closes (e.g., piped input ends)
+rl.on('close', () => {
+  isReadlineClosed = true;
+});
+
+/**
+ * Prompt user for approval decision
+ */
+async function promptForApproval(
+  filePath: string,
+  mode: 'read' | 'write' | 'search'
+): Promise<boolean> {
+  return new Promise((resolve) => {
+    // If readline is closed (e.g., non-TTY/piped input), auto-approve
+    if (isReadlineClosed) {
+      console.info(
+        `[${mode.toUpperCase()}] Access to ${filePath} auto-approved (non-interactive mode)`
+      );
+      resolve(true);
+      return;
+    }
+    rl.question(`[${mode.toUpperCase()}] Approve access to ${filePath}? (y/n): `, (answer) => {
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
+/**
+ * Example: Read tool using @tool decorator pattern
+ * Demonstrates class-based file reading with automatic decoration
+ */
+class FileReader {
+  @tool('read')
+  async readFile(filePath: string, startLine: number, endLine: number): Promise<unknown> {
+    // Decorator automatically intercepts and executes via Matimo
+    return undefined;
+  }
+
+  @tool('read')
+  async getFileMetadata(filePath: string): Promise<unknown> {
+    // Decorator automatically intercepts and executes via Matimo
+    return undefined;
+  }
+}
+
+async function decoratorExample() {
+  // Set up decorator support with autoDiscover
+  const matimo = await MatimoInstance.init({ autoDiscover: true });
+  setGlobalMatimoInstance(matimo);
+
+  // Set up approval callback for interactive approval
+  const approvalManager = getPathApprovalManager();
+  approvalManager.setApprovalCallback(promptForApproval);
+
+  console.info('=== Read Tool - Decorator Pattern (Interactive Approval) ===\n');
+
+  const reader = new FileReader();
+
+  try {
+    // Example 1: Read file through decorated method
+    console.info('1. Reading file: read-factory.ts (lines 1-15)\n');
+    const result1 = await reader.readFile(path.join(__dirname, './read-factory.ts'), 1, 15);
+    console.info('File:', (result1 as any).filePath);
+    console.info('Lines read:', (result1 as any).readLines);
+    console.info('Content preview:');
+    console.info((result1 as any).content?.substring(0, 200));
+    console.info('---\n');
+
+    // Example 2: Read another file
+    console.info('2. Reading file: package.json (lines 1-10)\n');
+    const result2 = await reader.getFileMetadata(path.join(__dirname, '../../../package.json'));
+    console.info('File:', (result2 as any).filePath);
+    console.info('Lines read:', (result2 as any).readLines);
+    console.info('Content preview:');
+    console.info((result2 as any).content?.substring(0, 200));
+    console.info('---\n');
+  } catch (error: any) {
+    console.error('Error:', error.message);
+  } finally {
+    if (!isReadlineClosed) {
+      rl.close();
+      isReadlineClosed = true;
+    }
+  }
+}
+
+decoratorExample();

package/read/read-factory.ts

@@ -0,0 +1,104 @@
+import { MatimoInstance } from '@matimo/core';
+import { getPathApprovalManager } from '@matimo/core';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import readline from 'readline';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Reusable readline interface kept open for multiple prompts
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+let isReadlineClosed = false;
+
+// Track when readline closes (e.g., piped input ends)
+rl.on('close', () => {
+  isReadlineClosed = true;
+});
+
+/**
+ * Interactive prompt helper for approval decisions
+ */
+async function promptForApproval(
+  filePath: string,
+  mode: 'read' | 'write' | 'search'
+): Promise<boolean> {
+  return new Promise((resolve) => {
+    // If readline is closed (e.g., non-TTY/piped input), auto-approve
+    if (isReadlineClosed) {
+      console.info(
+        `[${mode.toUpperCase()}] Access to ${filePath} auto-approved (non-interactive mode)`
+      );
+      resolve(true);
+      return;
+    }
+    rl.question(`[${mode.toUpperCase()}] Approve access to ${filePath}? (y/n): `, (answer) => {
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
+/**
+ * Example: Read tool using factory pattern
+ * Demonstrates reading file contents and metadata with interactive approval
+ */
+async function readExample() {
+  // Initialize Matimo with autoDiscover to find all tools (core + providers)
+  const matimo = await MatimoInstance.init({ autoDiscover: true });
+
+  // Set up approval callback for examples with INTERACTIVE PROMPTS
+  const approvalManager = getPathApprovalManager();
+  approvalManager.setApprovalCallback(promptForApproval);
+
+  console.info('=== Read Tool - Factory Pattern (Interactive Approval) ===\n');
+
+  try {
+    // Example 1: Read this example file
+    console.info('1. Reading read-factory.ts\n');
+    const result1 = await matimo.execute('read', {
+      filePath: path.join(__dirname, './read-factory.ts'),
+      startLine: 1,
+      endLine: 20,
+    });
+
+    if ((result1 as any).success) {
+      console.info('File:', (result1 as any).filePath);
+      console.info('Lines read:', (result1 as any).readLines);
+      console.info('Content preview:');
+      console.info((result1 as any).content?.substring(0, 300));
+    } else {
+      console.info('Access denied:', (result1 as any).error);
+    }
+    console.info('---\n');
+
+    // Example 2: Read package.json
+    console.info('2. Reading package.json\n');
+    const result2 = await matimo.execute('read', {
+      filePath: path.join(__dirname, '../../../package.json'),
+      startLine: 1,
+      endLine: 15,
+    });
+
+    if ((result2 as any).success) {
+      console.info('File:', (result2 as any).filePath);
+      console.info('Lines read:', (result2 as any).readLines);
+      console.info('Content preview:');
+      console.info((result2 as any).content?.substring(0, 200));
+    } else {
+      console.info('Access denied:', (result2 as any).error);
+    }
+    console.info('---\n');
+  } catch (error: any) {
+    console.error('Error reading file:', error.message, error.code, error.details);
+  } finally {
+    if (!isReadlineClosed) {
+      rl.close();
+      isReadlineClosed = true;
+    }
+  }
+}
+
+readExample();