escribano 0.1.4 → 0.2.2

package/dist/actions/generate-artifact-v3.js

@@ -7,10 +7,12 @@
 import { execSync } from 'node:child_process';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import path from 'node:path';
+import path, { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { log, step } from '../pipeline/context.js';
 import { normalizeAppNames } from '../services/app-normalization.js';
 import { groupTopicBlocksIntoSubjects, saveSubjectsToDatabase, } from '../services/subject-grouping.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
 export async function generateArtifactV3(recordingId, repos, intelligence, options) {
     const format = options.format || 'card';
     log('info', `[Artifact V3.1] Generating ${format} artifact for recording ${recordingId}...`);
@@ -204,7 +206,7 @@ async function generateLlmArtifact(subjects, groupingResult, format, recording,
         : format === 'standup'
             ? 'standup.md'
             : 'summary-v3.md';
-    const promptPath = path.join(process.cwd(), 'prompts', promptFileName);
+    const promptPath = resolve(__dirname, '..', '..', 'prompts', promptFileName);
     let promptTemplate;
     try {
         promptTemplate = await readFile(promptPath, 'utf-8');

package/dist/actions/generate-summary-v3.js

@@ -5,8 +5,10 @@
  */
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import path from 'node:path';
+import path, { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { log } from '../pipeline/context.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
 /**
  * Generate a work session summary artifact from processed TopicBlocks.
  *
@@ -81,7 +83,7 @@ export async function generateSummaryV3(recordingId, repos, intelligence, option
  */
 async function generateLlmSummary(sections, recording, intelligence) {
     // Read prompt template
-    const promptPath = path.join(process.cwd(), 'prompts', 'summary-v3.md');
+    const promptPath = resolve(__dirname, '..', '..', 'prompts', 'summary-v3.md');
     let promptTemplate;
     try {
         promptTemplate = await readFile(promptPath, 'utf-8');

package/dist/adapters/audio.silero.adapter.js

@@ -1,9 +1,12 @@
 import { exec, spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import { mkdir, readFile, rm } from 'node:fs/promises';
 import os from 'node:os';
-import path from 'node:path';
+import path, { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
 const execAsync = promisify(exec);
+const __dirname = dirname(fileURLToPath(import.meta.url));
 export function createSileroPreprocessor() {
     let currentProcess = null;
     return {
@@ -19,19 +22,63 @@ export function createSileroPreprocessor() {
             catch (error) {
                 throw new Error(`Failed to pre-convert audio for VAD: ${error.message}`);
             }
-            const scriptPath = path.join(process.cwd(), 'src', 'scripts', 'audio_preprocessor.py');
+            const scriptPath = resolve(__dirname, '..', '..', 'src', 'scripts', 'audio_preprocessor.py');
+            if (!existsSync(scriptPath)) {
+                throw new Error(`Audio preprocessor script not found at: ${scriptPath}`);
+            }
             const command = `uv run "${scriptPath}" --audio "${inputWavPath}" --output-dir "${tempDir}" --output-json "${manifestPath}"`;
             try {
                 console.log(`Running Silero VAD on ${inputWavPath}...`);
+                if (process.env.ESCRIBANO_VERBOSE === 'true') {
+                    console.log(`  Script path: ${scriptPath}`);
+                    console.log(`  Script exists: ${existsSync(scriptPath)}`);
+                    console.log(`  Command: ${command}`);
+                    console.log(`  Working directory (user): ${process.cwd()}`);
+                    try {
+                        const { stdout: uvVersion } = await execAsync('uv --version');
+                        console.log(`  uv version: ${uvVersion.trim()}`);
+                    }
+                    catch {
+                        console.log(`  uv version: NOT FOUND`);
+                    }
+                }
                 currentProcess = spawn('sh', ['-c', command]);
+                let stderr = '';
+                let stdout = '';
+                if (currentProcess.stderr) {
+                    currentProcess.stderr.on('data', (data) => {
+                        stderr += data.toString();
+                    });
+                }
+                if (currentProcess.stdout) {
+                    currentProcess.stdout.on('data', (data) => {
+                        stdout += data.toString();
+                    });
+                }
                 await new Promise((resolve, reject) => {
                     currentProcess?.on('close', (code) => {
                         currentProcess = null;
                         if (code === 0) {
+                            if (process.env.ESCRIBANO_VERBOSE === 'true' && stdout) {
+                                console.log(`  Silero VAD stdout:\n${stdout
+                                    .split('\n')
+                                    .map((l) => '    ' + l)
+                                    .join('\n')}`);
+                            }
                             resolve();
                         }
                         else {
-                            reject(new Error(`Silero VAD failed with code ${code}`));
+                            console.error(`  Silero VAD stderr:\n${stderr
+                                .split('\n')
+                                .map((l) => '    ' + l)
+                                .join('\n')}`);
+                            if (stdout) {
+                                console.error(`  Silero VAD stdout:\n${stdout
+                                    .split('\n')
+                                    .map((l) => '    ' + l)
+                                    .join('\n')}`);
+                            }
+                            reject(new Error(`Silero VAD failed with code ${code}: ${stderr || stdout || 'No output captured'}`));
                         }
                     });
                     currentProcess?.on('error', (err) => {

package/dist/adapters/intelligence.ollama.adapter.js

@@ -4,12 +4,14 @@
  * Implements IntelligenceService using Ollama REST API
  */
 import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { Agent, fetch as undiciFetch } from 'undici';
 import { z } from 'zod';
 import { classificationSchema, intelligenceConfigSchema, transcriptMetadataSchema, } from '../0_types.js';
 // Debug logging controlled by environment variable
 const DEBUG_OLLAMA = process.env.ESCRIBANO_DEBUG_OLLAMA === 'true';
+const __dirname = dirname(fileURLToPath(import.meta.url));
 // TODO: put in an util
 export function debugLog(...args) {
     if (DEBUG_OLLAMA) {
@@ -193,7 +195,7 @@ async function classifySegmentWithOllama(segment, config, transcript) {
     return raw;
 }
 function loadClassifySegmentPrompt(segment, transcript) {
-    const promptPath = join(process.cwd(), 'prompts', 'classify-segment.md');
+    const promptPath = resolve(__dirname, '..', '..', 'prompts', 'classify-segment.md');
     let prompt = readFileSync(promptPath, 'utf-8');
     const timeRangeStr = `[${segment.timeRange[0]}s - ${segment.timeRange[1]}s]`;
     const ocrContext = segment.contexts.map((c) => `${c.type}: ${c.value}`).join(', ') || 'None';
@@ -208,7 +210,7 @@ function loadClassifySegmentPrompt(segment, transcript) {
     return prompt;
 }
 function loadClassifyPrompt(transcript, visualLogs) {
-    const promptPath = join(process.cwd(), 'prompts', 'classify.md');
+    const promptPath = resolve(__dirname, '..', '..', 'prompts', 'classify.md');
     let prompt = readFileSync(promptPath, 'utf-8');
     const segmentsText = transcript.segments
         .map((seg) => `[seg-${seg.id}] [${seg.start}s - ${seg.end}s] ${seg.text}`)
@@ -241,7 +243,7 @@ function loadClassifyPrompt(transcript, visualLogs) {
  */
 function buildVLMSingleImagePrompt() {
     try {
-        const promptPath = join(process.cwd(), 'prompts', 'vlm-single.md');
+        const promptPath = resolve(__dirname, '..', '..', 'prompts', 'vlm-single.md');
         return readFileSync(promptPath, 'utf-8');
     }
     catch {
@@ -426,7 +428,7 @@ async function extractTopicsWithOllama(observations, config) {
         return [];
     let prompt;
     try {
-        const promptPath = join(process.cwd(), 'prompts', 'topic-extract.md');
+        const promptPath = resolve(__dirname, '..', '..', 'prompts', 'topic-extract.md');
         const template = readFileSync(promptPath, 'utf-8');
         prompt = template.replace('{{OBSERVATIONS}}', textSamples.join('\n---\n'));
     }
@@ -657,7 +659,7 @@ async function extractMetadata(transcript, classification, config, visualLogs) {
     return raw;
 }
 function loadMetadataPrompt(transcript, classification, visualLogs) {
-    const promptPath = join(process.cwd(), 'prompts', 'extract-metadata.md');
+    const promptPath = resolve(__dirname, '..', '..', 'prompts', 'extract-metadata.md');
     let prompt = readFileSync(promptPath, 'utf-8');
     const classificationSummary = Object.entries(classification)
         .filter(([_, score]) => score >= 25)
@@ -698,7 +700,7 @@ async function generateArtifact(artifactType, context, config) {
     return response;
 }
 function loadArtifactPrompt(artifactType, context) {
-    const promptPath = join(process.cwd(), 'prompts', `${artifactType}.md`);
+    const promptPath = resolve(__dirname, '..', '..', 'prompts', `${artifactType}.md`);
     let prompt = readFileSync(promptPath, 'utf-8');
     // TODO: Implement robust transcript cleaning (Milestone 4)
     prompt = prompt.replace('{{TRANSCRIPT_ALL}}', context.transcript.fullText);

package/dist/adapters/video.ffmpeg.adapter.js

@@ -5,12 +5,15 @@
  * Used for extracting screenshots and detecting scene changes.
  */
 import { exec, spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import { mkdir, readdir, readFile, rm } from 'node:fs/promises';
 import os from 'node:os';
-import path from 'node:path';
+import path, { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
 import { debugLog } from './intelligence.ollama.adapter.js';
 const execAsync = promisify(exec);
+const __dirname = dirname(fileURLToPath(import.meta.url));
 // Scene detection configuration (with env var overrides)
 // Lower threshold = more sensitive = more scene changes detected
 // Examples: 0.3 (sensitive), 0.4 (default), 0.5 (conservative)
@@ -268,15 +271,16 @@ export function createFfmpegVideoService() {
          * OCR is parallelized across all available CPU cores.
          */
         runVisualIndexing: async (framesDir, outputPath) => {
-            const scriptPath = path.join(process.cwd(), 'src', 'scripts', 'visual_observer_base.py');
+            const scriptPath = resolve(__dirname, '..', '..', 'src', 'scripts', 'visual_observer_base.py');
+            if (!existsSync(scriptPath)) {
+                throw new Error(`Visual observer script not found at: ${scriptPath}`);
+            }
             const frameInterval = Number(process.env.ESCRIBANO_FRAME_INTERVAL) || 2;
             const workers = os.cpus().length;
-            // Use uv run to execute the script with its environment
-            // --workers enables parallel OCR processing
             const command = `uv run "${scriptPath}" --frames-dir "${framesDir}" --output "${outputPath}" --frame-interval ${frameInterval} --workers ${workers}`;
             try {
                 await execAsync(command, {
-                    cwd: path.join(process.cwd(), 'src', 'scripts'),
+                    cwd: dirname(scriptPath),
                 });
                 const content = await readFile(outputPath, 'utf-8');
                 return JSON.parse(content);

package/dist/index.js

@@ -7,16 +7,22 @@
  */
 import { homedir } from 'node:os';
 import path from 'node:path';
+import pkg from '../package.json' with { type: 'json' };
 import { createCapCaptureSource } from './adapters/capture.cap.adapter.js';
 import { createFilesystemCaptureSource } from './adapters/capture.filesystem.adapter.js';
 import { cleanupMlxBridge, initializeSystem, processVideo, } from './batch-context.js';
 import { getDbPath } from './db/index.js';
 import { checkPrerequisites, hasMissingPrerequisites, printDoctorResults, } from './prerequisites.js';
+import { logEnvironmentVariables } from './utils/env-logger.js';
 const MODELS_DIR = path.join(homedir(), '.escribano', 'models');
 const MODEL_FILE = 'ggml-large-v3.bin';
 const MODEL_PATH = path.join(MODELS_DIR, MODEL_FILE);
 function main() {
     const args = parseArgs(process.argv.slice(2));
+    if (args.version) {
+        console.log(`escribano v${pkg.version}`);
+        process.exit(0);
+    }
     if (args.help) {
         showHelp();
         process.exit(0);
@@ -53,6 +59,7 @@ function parseArgs(argsArray) {
     return {
         force: argsArray.includes('--force'),
         help: argsArray.includes('--help') || argsArray.includes('-h'),
+        version: argsArray.includes('--version') || argsArray.includes('-v'),
         doctor: argsArray[0] === 'doctor',
         file: filePath,
         skipSummary: argsArray.includes('--skip-summary'),
@@ -82,6 +89,7 @@ Usage:
   npx escribano --include-personal        Include personal time in artifact
   npx escribano --copy                    Copy artifact to clipboard
   npx escribano --stdout                  Print artifact to stdout
+  npx escribano --version                 Show version number
   npx escribano --help                    Show this help
 
 Examples:
@@ -96,6 +104,8 @@ Output: Markdown summary saved to ~/.escribano/artifacts/
 }
 async function run(args) {
     const { force, file: filePath, skipSummary, micAudio, systemAudio, format, includePersonal, copyToClipboard, printToStdout, } = args;
+    // Log environment variables if verbose mode is enabled
+    logEnvironmentVariables();
     // Initialize system (reuses batch-context for consistency)
     console.log('Initializing database...');
     const ctx = await initializeSystem();

package/dist/services/subject-grouping.js

@@ -5,7 +5,9 @@
  * This is the foundation for the new artifact architecture.
  */
 import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
 const PERSONAL_APPS = new Set([
     'WhatsApp',
     'Instagram',
@@ -144,7 +146,7 @@ ID: ${b.id}`;
         : `"${blockIdList[0]}"`;
     let template;
     try {
-        const promptPath = join(process.cwd(), 'prompts', 'subject-grouping.md');
+        const promptPath = resolve(__dirname, '..', '..', 'prompts', 'subject-grouping.md');
         template = readFileSync(promptPath, 'utf-8');
     }
     catch {

package/dist/tests/utils/env-logger.test.js

@@ -0,0 +1,262 @@
+import { readFileSync } from 'node:fs';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+// Mock fs module
+vi.mock('node:fs', () => ({
+    readFileSync: vi.fn(),
+}));
+// Mock process.env
+const originalEnv = { ...process.env };
+beforeEach(() => {
+    vi.clearAllMocks();
+    // Reset process.env
+    process.env = { ...originalEnv };
+});
+// Import after mocking
+const { logEnvironmentVariables } = await import('../../utils/env-logger.js');
+describe('Environment Variable Logger', () => {
+    describe('parseEnvExample', () => {
+        it('parses simple variable with description', async () => {
+            const mockContent = `# Enable verbose logging
+ESCRIBANO_VERBOSE=false`;
+            vi.mocked(readFileSync).mockReturnValue(mockContent);
+            // Call the function indirectly via logEnvironmentVariables
+            process.env.ESCRIBANO_VERBOSE = 'true';
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            expect(consoleSpy).toHaveBeenCalled();
+            const output = consoleSpy.mock.calls
+                .map((call) => call.join(' '))
+                .join('\n');
+            expect(output).toContain('ESCRIBANO_VERBOSE');
+            expect(output).toContain('Enable verbose logging');
+            consoleSpy.mockRestore();
+        });
+        it('skips section headers', async () => {
+            const mockContent = `# === Frame Extraction ===
+# Output frame width
+ESCRIBANO_FRAME_WIDTH=1024`;
+            vi.mocked(readFileSync).mockReturnValue(mockContent);
+            process.env.ESCRIBANO_VERBOSE = 'true';
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            const output = consoleSpy.mock.calls
+                .map((call) => call.join(' '))
+                .join('\n');
+            expect(output).toContain('ESCRIBANO_FRAME_WIDTH');
+            expect(output).toContain('Output frame width');
+            expect(output).not.toContain('Frame Extraction');
+            consoleSpy.mockRestore();
+        });
+        it('skips commented/deprecated variables', async () => {
+            const mockContent = `# Active variable
+ESCRIBANO_VERBOSE=false
+# ESCRIBANO_DEPRECATED=value`;
+            vi.mocked(readFileSync).mockReturnValue(mockContent);
+            process.env.ESCRIBANO_VERBOSE = 'true';
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            const output = consoleSpy.mock.calls
+                .map((call) => call.join(' '))
+                .join('\n');
+            expect(output).toContain('ESCRIBANO_VERBOSE');
+            expect(output).not.toContain('ESCRIBANO_DEPRECATED');
+            consoleSpy.mockRestore();
+        });
+        it('skips non-ESCRIBANO variables', async () => {
+            const mockContent = `ESCRIBANO_VERBOSE=false
+OTHER_VAR=value`;
+            vi.mocked(readFileSync).mockReturnValue(mockContent);
+            process.env.ESCRIBANO_VERBOSE = 'true';
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            const output = consoleSpy.mock.calls
+                .map((call) => call.join(' '))
+                .join('\n');
+            expect(output).toContain('ESCRIBANO_VERBOSE');
+            expect(output).not.toContain('OTHER_VAR');
+            consoleSpy.mockRestore();
+        });
+        it('handles empty file gracefully', async () => {
+            vi.mocked(readFileSync).mockReturnValue('');
+            process.env.ESCRIBANO_VERBOSE = 'true';
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            const output = consoleSpy.mock.calls
+                .map((call) => call.join(' '))
+                .join('\n');
+            expect(output).toContain('Environment Variables');
+            consoleSpy.mockRestore();
+        });
+        it('handles file not found gracefully', async () => {
+            vi.mocked(readFileSync).mockImplementation(() => {
+                throw new Error('ENOENT');
+            });
+            process.env.ESCRIBANO_VERBOSE = 'true';
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            const output = consoleSpy.mock.calls
+                .map((call) => call.join(' '))
+                .join('\n');
+            expect(output).toContain('Could not parse .env.example');
+            consoleSpy.mockRestore();
+        });
+    });
+    describe('logEnvironmentVariables', () => {
+        it('does not log when ESCRIBANO_VERBOSE is false', () => {
+            process.env.ESCRIBANO_VERBOSE = 'false';
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            expect(consoleSpy).not.toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        });
+        it('does not log when ESCRIBANO_VERBOSE is not set', () => {
+            delete process.env.ESCRIBANO_VERBOSE;
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            expect(consoleSpy).not.toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        });
+        it('logs when ESCRIBANO_VERBOSE is true', () => {
+            const mockContent = 'ESCRIBANO_VERBOSE=false';
+            vi.mocked(readFileSync).mockReturnValue(mockContent);
+            process.env.ESCRIBANO_VERBOSE = 'true';
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            expect(consoleSpy).toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        });
+        it('marks custom values with [CUSTOM]', () => {
+            const mockContent = `# Default batch size
+ESCRIBANO_VLM_BATCH_SIZE=4`;
+            vi.mocked(readFileSync).mockReturnValue(mockContent);
+            process.env.ESCRIBANO_VERBOSE = 'true';
+            process.env.ESCRIBANO_VLM_BATCH_SIZE = '8';
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            const output = consoleSpy.mock.calls
+                .map((call) => call.join(' '))
+                .join('\n');
+            expect(output).toContain('[CUSTOM]');
+            expect(output).toContain('Current: 8');
+            expect(output).toContain('Default: 4');
+            consoleSpy.mockRestore();
+        });
+        it('does not mark default values', () => {
+            const mockContent = `# Default batch size
+ESCRIBANO_VLM_BATCH_SIZE=4`;
+            vi.mocked(readFileSync).mockReturnValue(mockContent);
+            process.env.ESCRIBANO_VERBOSE = 'true';
+            process.env.ESCRIBANO_VLM_BATCH_SIZE = '4';
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            const output = consoleSpy.mock.calls
+                .map((call) => call.join(' '))
+                .join('\n');
+            expect(output).not.toContain('[CUSTOM]');
+            consoleSpy.mockRestore();
+        });
+        it('masks secret tokens', () => {
+            const mockContent = `ESCRIBANO_OUTLINE_TOKEN=`;
+            vi.mocked(readFileSync).mockReturnValue(mockContent);
+            process.env.ESCRIBANO_VERBOSE = 'true';
+            process.env.ESCRIBANO_OUTLINE_TOKEN = 'secret-api-key-123';
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            const output = consoleSpy.mock.calls
+                .map((call) => call.join(' '))
+                .join('\n');
+            expect(output).toContain('***');
+            expect(output).not.toContain('secret-api-key-123');
+            consoleSpy.mockRestore();
+        });
+        it('does not mask non-secret values', () => {
+            const mockContent = `ESCRIBANO_VLM_BATCH_SIZE=4`;
+            vi.mocked(readFileSync).mockReturnValue(mockContent);
+            process.env.ESCRIBANO_VERBOSE = 'true';
+            process.env.ESCRIBANO_VLM_BATCH_SIZE = '8';
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            const output = consoleSpy.mock.calls
+                .map((call) => call.join(' '))
+                .join('\n');
+            expect(output).toContain('8');
+            expect(output).not.toContain('***');
+            consoleSpy.mockRestore();
+        });
+        it('shows "not set" for undefined variables', () => {
+            const mockContent = `ESCRIBANO_VLM_BATCH_SIZE=4`;
+            vi.mocked(readFileSync).mockReturnValue(mockContent);
+            process.env.ESCRIBANO_VERBOSE = 'true';
+            delete process.env.ESCRIBANO_VLM_BATCH_SIZE;
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            const output = consoleSpy.mock.calls
+                .map((call) => call.join(' '))
+                .join('\n');
+            expect(output).toContain('not set');
+            consoleSpy.mockRestore();
+        });
+        it('shows "(empty)" for empty default values', () => {
+            const mockContent = `ESCRIBANO_OUTLINE_TOKEN=`;
+            vi.mocked(readFileSync).mockReturnValue(mockContent);
+            process.env.ESCRIBANO_VERBOSE = 'true';
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            const output = consoleSpy.mock.calls
+                .map((call) => call.join(' '))
+                .join('\n');
+            expect(output).toContain('(empty)');
+            consoleSpy.mockRestore();
+        });
+        it('sorts variables alphabetically', () => {
+            const mockContent = `ESCRIBANO_ZEBRA=1
+ESCRIBANO_ALPHA=2
+ESCRIBANO_MIDDLE=3`;
+            vi.mocked(readFileSync).mockReturnValue(mockContent);
+            process.env.ESCRIBANO_VERBOSE = 'true';
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            const output = consoleSpy.mock.calls
+                .map((call) => call.join(' '))
+                .join('\n');
+            const alphaIndex = output.indexOf('ESCRIBANO_ALPHA');
+            const middleIndex = output.indexOf('ESCRIBANO_MIDDLE');
+            const zebraIndex = output.indexOf('ESCRIBANO_ZEBRA');
+            expect(alphaIndex).toBeLessThan(middleIndex);
+            expect(middleIndex).toBeLessThan(zebraIndex);
+            consoleSpy.mockRestore();
+        });
+        it('includes multi-line descriptions', () => {
+            const mockContent = `# First line of description
+# Second line of description
+ESCRIBANO_VERBOSE=false`;
+            vi.mocked(readFileSync).mockReturnValue(mockContent);
+            process.env.ESCRIBANO_VERBOSE = 'true';
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            const output = consoleSpy.mock.calls
+                .map((call) => call.join(' '))
+                .join('\n');
+            expect(output).toContain('First line of description');
+            expect(output).toContain('Second line of description');
+            consoleSpy.mockRestore();
+        });
+    });
+    describe('text wrapping', () => {
+        it('wraps long descriptions to fit width', () => {
+            const longDescription = 'This is a very long description that should be wrapped across multiple lines to fit within the specified width limit for better readability in the console output';
+            const mockContent = `# ${longDescription}
+ESCRIBANO_VERBOSE=false`;
+            vi.mocked(readFileSync).mockReturnValue(mockContent);
+            process.env.ESCRIBANO_VERBOSE = 'true';
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            logEnvironmentVariables();
+            // The description should appear in the output
+            const output = consoleSpy.mock.calls
+                .map((call) => call.join(' '))
+                .join('\n');
+            expect(output).toContain('very long description');
+            consoleSpy.mockRestore();
+        });
+    });
+});