start-command 0.15.0 → 0.16.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # start-command
 
+## 0.16.0
+
+### Minor Changes
+
+- 35f3505: feat: Improve command output formatting with human-readable timestamps and duration
+  - Changed timestamp format from `[timestamp] Starting:` to `Starting at timestamp:`
+  - Changed finish message from `[timestamp] Finished` to `Finished at timestamp in X.XXX seconds`
+  - Added performance metric showing command execution duration
+  - Added `formatDuration` helper function for consistent duration formatting
+
 ## 0.15.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Gamification of coding, execute any command with ability to auto-report issues on GitHub",
   "main": "src/bin/cli.js",
   "exports": {

package/src/bin/cli.js

@@ -33,6 +33,7 @@ const { handleFailure } = require('../lib/failure-handler');
 const { ExecutionStore, ExecutionRecord } = require('../lib/execution-store');
 const { queryStatus } = require('../lib/status-formatter');
 const { printVersion } = require('../lib/version');
+const { createStartBlock, createFinishBlock } = require('../lib/output-blocks');
 
 // Configuration from environment variables
 const config = {
@@ -283,6 +284,7 @@ async function runWithIsolation(
   const environment = options.isolated;
   const mode = getEffectiveMode(options);
   const startTime = getTimestamp();
+  const startTimeMs = Date.now();
 
   // Create log file path
   const logFilePath = createLogPath(environment || 'direct');
@@ -319,8 +321,14 @@ async function runWithIsolation(
     });
   }
 
-  // Print session UUID at start
-  console.log(sessionId);
+  // Print start block with session ID
+  console.log(
+    createStartBlock({
+      sessionId,
+      timestamp: startTime,
+      command: cmd,
+    })
+  );
   console.log('');
 
   // Handle --isolated-user option: create a new user with same permissions
@@ -373,10 +381,6 @@ async function runWithIsolation(
     console.log('');
   }
 
-  // Print start message (unified format)
-  console.log(`[${startTime}] Starting: ${cmd}`);
-  console.log('');
-
   // Log isolation info
   if (environment) {
     console.log(`[Isolation] Environment: ${environment}, Mode: ${mode}`);
@@ -479,13 +483,9 @@ async function runWithIsolation(
     }
   }
 
-  // Print result and footer (unified format)
+  // Print result
   console.log('');
   console.log(result.message);
-  console.log('');
-  console.log(`[${endTime}] Finished`);
-  console.log(`Exit code: ${exitCode}`);
-  console.log(`Log saved: ${logFilePath}`);
 
   // Cleanup: delete the created user if we created one (unless --keep-user)
   if (createdUser && !options.keepUser) {
@@ -504,9 +504,18 @@ async function runWithIsolation(
     );
   }
 
-  // Print session UUID at end
+  // Print finish block
+  const durationMs = Date.now() - startTimeMs;
   console.log('');
-  console.log(sessionId);
+  console.log(
+    createFinishBlock({
+      sessionId,
+      timestamp: endTime,
+      exitCode,
+      logPath: logFilePath,
+      durationMs,
+    })
+  );
 
   process.exit(exitCode);
 }
@@ -532,6 +541,7 @@ function runDirect(cmd, sessionId) {
 
   let logContent = '';
   const startTime = getTimestamp();
+  const startTimeMs = Date.now();
 
   // Get runtime information
   const runtime = typeof Bun !== 'undefined' ? 'Bun' : 'Node.js';
@@ -574,17 +584,18 @@ function runDirect(cmd, sessionId) {
   logContent += `Working Directory: ${process.cwd()}\n`;
   logContent += `${'='.repeat(50)}\n\n`;
 
-  // Print session UUID at start
-  console.log(sessionId);
-  console.log('');
-
-  // Print start message to console
-  if (substitutionResult && substitutionResult.matched) {
-    console.log(`[${startTime}] Input: ${parsedCommand}`);
-    console.log(`[${startTime}] Executing: ${cmd}`);
-  } else {
-    console.log(`[${startTime}] Starting: ${cmd}`);
-  }
+  // Print start block with session ID
+  const displayCommand =
+    substitutionResult && substitutionResult.matched
+      ? `${parsedCommand} -> ${cmd}`
+      : cmd;
+  console.log(
+    createStartBlock({
+      sessionId,
+      timestamp: startTime,
+      command: displayCommand,
+    })
+  );
   console.log('');
 
   // Execute the command with captured output
@@ -652,14 +663,18 @@ function runDirect(cmd, sessionId) {
       }
     }
 
-    // Print footer to console
-    console.log('');
-    console.log(`[${endTime}] Finished`);
-    console.log(`Exit code: ${exitCode}`);
-    console.log(`Log saved: ${logFilePath}`);
+    // Print finish block
+    const durationMs = Date.now() - startTimeMs;
     console.log('');
-    // Print session UUID at end
-    console.log(sessionId);
+    console.log(
+      createFinishBlock({
+        sessionId,
+        timestamp: endTime,
+        exitCode,
+        logPath: logFilePath,
+        durationMs,
+      })
+    );
 
     // If command failed, try to auto-report
     if (exitCode !== 0) {
@@ -672,6 +687,7 @@ function runDirect(cmd, sessionId) {
   // Handle spawn errors
   child.on('error', (err) => {
     const endTime = getTimestamp();
+    const durationMs = Date.now() - startTimeMs;
     const errorMessage = `Error executing command: ${err.message}`;
 
     logContent += `\n${errorMessage}\n`;
@@ -702,12 +718,15 @@ function runDirect(cmd, sessionId) {
 
     console.error(`\n${errorMessage}`);
     console.log('');
-    console.log(`[${endTime}] Finished`);
-    console.log(`Exit code: 1`);
-    console.log(`Log saved: ${logFilePath}`);
-    console.log('');
-    // Print session UUID at end
-    console.log(sessionId);
+    console.log(
+      createFinishBlock({
+        sessionId,
+        timestamp: endTime,
+        exitCode: 1,
+        logPath: logFilePath,
+        durationMs,
+      })
+    );
 
     handleFailure(config, commandName, cmd, 1, logFilePath);
 
@@ -746,6 +765,7 @@ async function runDirectWithCommandStream(
 
   let logContent = '';
   const startTime = getTimestamp();
+  const startTimeMs = Date.now();
 
   // Get runtime information
   const runtime = typeof Bun !== 'undefined' ? 'Bun' : 'Node.js';
@@ -790,17 +810,16 @@ async function runDirectWithCommandStream(
   logContent += `Working Directory: ${process.cwd()}\n`;
   logContent += `${'='.repeat(50)}\n\n`;
 
-  // Print session UUID at start
-  console.log(sessionId);
-  console.log('');
-
-  // Print start message to console
-  if (subResult && subResult.matched) {
-    console.log(`[${startTime}] Input: ${parsedCmd}`);
-    console.log(`[${startTime}] Executing: ${cmd}`);
-  } else {
-    console.log(`[${startTime}] Starting: ${cmd}`);
-  }
+  // Print start block with session ID
+  const displayCmd =
+    subResult && subResult.matched ? `${parsedCmd} -> ${cmd}` : cmd;
+  console.log(
+    createStartBlock({
+      sessionId,
+      timestamp: startTime,
+      command: displayCmd,
+    })
+  );
   console.log('[command-stream] Using command-stream library');
   console.log('');
 
@@ -876,14 +895,18 @@ async function runDirectWithCommandStream(
     }
   }
 
-  // Print footer to console
+  // Print finish block
+  const durationMs = Date.now() - startTimeMs;
   console.log('');
-  console.log(`[${endTime}] Finished`);
-  console.log(`Exit code: ${exitCode}`);
-  console.log(`Log saved: ${logFilePath}`);
-  console.log('');
-  // Print session UUID at end
-  console.log(sessionId);
+  console.log(
+    createFinishBlock({
+      sessionId,
+      timestamp: endTime,
+      exitCode,
+      logPath: logFilePath,
+      durationMs,
+    })
+  );
 
   // If command failed, try to auto-report
   if (exitCode !== 0) {

package/src/lib/output-blocks.js

@@ -0,0 +1,357 @@
+/**
+ * Output formatting utilities for nicely rendered command blocks
+ *
+ * Provides various styles for start/finish blocks to distinguish
+ * command output from the $ wrapper output.
+ *
+ * Available styles:
+ * 1. 'rounded' (default): Rounded unicode box borders (╭─╮ ╰─╯)
+ * 2. 'heavy': Heavy unicode box borders (┏━┓ ┗━┛)
+ * 3. 'double': Double line box borders (╔═╗ ╚═╝)
+ * 4. 'simple': Simple dash lines (────────)
+ * 5. 'ascii': Pure ASCII compatible (-------- +------+)
+ */
+
+// Box drawing characters for different styles
+const BOX_STYLES = {
+  rounded: {
+    topLeft: '╭',
+    topRight: '╮',
+    bottomLeft: '╰',
+    bottomRight: '╯',
+    horizontal: '─',
+    vertical: '│',
+  },
+  heavy: {
+    topLeft: '┏',
+    topRight: '┓',
+    bottomLeft: '┗',
+    bottomRight: '┛',
+    horizontal: '━',
+    vertical: '┃',
+  },
+  double: {
+    topLeft: '╔',
+    topRight: '╗',
+    bottomLeft: '╚',
+    bottomRight: '╝',
+    horizontal: '═',
+    vertical: '║',
+  },
+  simple: {
+    topLeft: '',
+    topRight: '',
+    bottomLeft: '',
+    bottomRight: '',
+    horizontal: '─',
+    vertical: '',
+  },
+  ascii: {
+    topLeft: '+',
+    topRight: '+',
+    bottomLeft: '+',
+    bottomRight: '+',
+    horizontal: '-',
+    vertical: '|',
+  },
+};
+
+// Default style (can be overridden via environment variable)
+const DEFAULT_STYLE = process.env.START_OUTPUT_STYLE || 'rounded';
+
+// Default block width
+const DEFAULT_WIDTH = 60;
+
+/**
+ * Get the box style configuration
+ * @param {string} [styleName] - Style name (rounded, heavy, double, simple, ascii)
+ * @returns {object} Box style configuration
+ */
+function getBoxStyle(styleName = DEFAULT_STYLE) {
+  return BOX_STYLES[styleName] || BOX_STYLES.rounded;
+}
+
+/**
+ * Create a horizontal line
+ * @param {number} width - Line width
+ * @param {object} style - Box style
+ * @returns {string} Horizontal line
+ */
+function createHorizontalLine(width, style) {
+  return style.horizontal.repeat(width);
+}
+
+/**
+ * Pad or truncate text to fit a specific width
+ * @param {string} text - Text to pad
+ * @param {number} width - Target width
+ * @returns {string} Padded text
+ */
+function padText(text, width) {
+  if (text.length >= width) {
+    return text.substring(0, width);
+  }
+  return text + ' '.repeat(width - text.length);
+}
+
+/**
+ * Create a bordered line with text
+ * @param {string} text - Text content
+ * @param {number} width - Total width (including borders)
+ * @param {object} style - Box style
+ * @returns {string} Bordered line
+ */
+function createBorderedLine(text, width, style) {
+  if (style.vertical) {
+    const innerWidth = width - 4; // 2 for borders, 2 for padding
+    const paddedText = padText(text, innerWidth);
+    return `${style.vertical} ${paddedText} ${style.vertical}`;
+  }
+  return text;
+}
+
+/**
+ * Create the top border of a box
+ * @param {number} width - Box width
+ * @param {object} style - Box style
+ * @returns {string} Top border
+ */
+function createTopBorder(width, style) {
+  if (style.topLeft) {
+    const lineWidth = width - 2; // Subtract corners
+    return `${style.topLeft}${createHorizontalLine(lineWidth, style)}${style.topRight}`;
+  }
+  return createHorizontalLine(width, style);
+}
+
+/**
+ * Create the bottom border of a box
+ * @param {number} width - Box width
+ * @param {object} style - Box style
+ * @returns {string} Bottom border
+ */
+function createBottomBorder(width, style) {
+  if (style.bottomLeft) {
+    const lineWidth = width - 2; // Subtract corners
+    return `${style.bottomLeft}${createHorizontalLine(lineWidth, style)}${style.bottomRight}`;
+  }
+  return createHorizontalLine(width, style);
+}
+
+/**
+ * Create a start block for command execution
+ * @param {object} options - Options for the block
+ * @param {string} options.sessionId - Session UUID
+ * @param {string} options.timestamp - Timestamp string
+ * @param {string} options.command - Command being executed
+ * @param {string} [options.style] - Box style name
+ * @param {number} [options.width] - Box width
+ * @returns {string} Formatted start block
+ */
+function createStartBlock(options) {
+  const {
+    sessionId,
+    timestamp,
+    command,
+    style: styleName = DEFAULT_STYLE,
+    width = DEFAULT_WIDTH,
+  } = options;
+
+  const style = getBoxStyle(styleName);
+  const lines = [];
+
+  lines.push(createTopBorder(width, style));
+  lines.push(createBorderedLine(`Session ID: ${sessionId}`, width, style));
+  lines.push(
+    createBorderedLine(`Starting at ${timestamp}: ${command}`, width, style)
+  );
+  lines.push(createBottomBorder(width, style));
+
+  return lines.join('\n');
+}
+
+/**
+ * Format duration in seconds with appropriate precision
+ * @param {number} durationMs - Duration in milliseconds
+ * @returns {string} Formatted duration string
+ */
+function formatDuration(durationMs) {
+  const seconds = durationMs / 1000;
+  if (seconds < 0.001) {
+    return '0.001';
+  } else if (seconds < 10) {
+    // For durations under 10 seconds, show 3 decimal places
+    return seconds.toFixed(3);
+  } else if (seconds < 100) {
+    return seconds.toFixed(2);
+  } else {
+    return seconds.toFixed(1);
+  }
+}
+
+/**
+ * Create a finish block for command execution
+ * @param {object} options - Options for the block
+ * @param {string} options.sessionId - Session UUID
+ * @param {string} options.timestamp - Timestamp string
+ * @param {number} options.exitCode - Exit code
+ * @param {string} options.logPath - Path to log file
+ * @param {number} [options.durationMs] - Duration in milliseconds
+ * @param {string} [options.style] - Box style name
+ * @param {number} [options.width] - Box width
+ * @returns {string} Formatted finish block
+ */
+function createFinishBlock(options) {
+  const {
+    sessionId,
+    timestamp,
+    exitCode,
+    logPath,
+    durationMs,
+    style: styleName = DEFAULT_STYLE,
+    width = DEFAULT_WIDTH,
+  } = options;
+
+  const style = getBoxStyle(styleName);
+  const lines = [];
+
+  // Format the finished message with optional duration
+  let finishedMsg = `Finished at ${timestamp}`;
+  if (durationMs !== undefined && durationMs !== null) {
+    finishedMsg += ` in ${formatDuration(durationMs)} seconds`;
+  }
+
+  lines.push(createTopBorder(width, style));
+  lines.push(createBorderedLine(finishedMsg, width, style));
+  lines.push(createBorderedLine(`Exit code: ${exitCode}`, width, style));
+  lines.push(createBorderedLine(`Log: ${logPath}`, width, style));
+  lines.push(createBorderedLine(`Session ID: ${sessionId}`, width, style));
+  lines.push(createBottomBorder(width, style));
+
+  return lines.join('\n');
+}
+
+/**
+ * Escape a value for Links notation
+ * Smart quoting: uses single or double quotes based on content
+ * @param {string} str - String to escape
+ * @returns {string} Escaped string
+ */
+function escapeForLinksNotation(str) {
+  if (str === null || str === undefined) {
+    return 'null';
+  }
+
+  const value = String(str);
+
+  // Check for characters that need quoting
+  const hasColon = value.includes(':');
+  const hasDoubleQuotes = value.includes('"');
+  const hasSingleQuotes = value.includes("'");
+  const hasParens = value.includes('(') || value.includes(')');
+  const hasNewline = value.includes('\n');
+  const hasSpace = value.includes(' ');
+
+  const needsQuoting =
+    hasColon ||
+    hasDoubleQuotes ||
+    hasSingleQuotes ||
+    hasParens ||
+    hasNewline ||
+    hasSpace;
+
+  if (!needsQuoting) {
+    return value;
+  }
+
+  if (hasDoubleQuotes && !hasSingleQuotes) {
+    // Has " but not ' → use single quotes
+    return `'${value}'`;
+  } else if (hasSingleQuotes && !hasDoubleQuotes) {
+    // Has ' but not " → use double quotes
+    return `"${value}"`;
+  } else if (hasDoubleQuotes && hasSingleQuotes) {
+    // Has both " and ' → choose wrapper with fewer escapes
+    const doubleQuoteCount = (value.match(/"/g) || []).length;
+    const singleQuoteCount = (value.match(/'/g) || []).length;
+
+    if (singleQuoteCount <= doubleQuoteCount) {
+      // Escape single quotes by doubling them
+      const escaped = value.replace(/'/g, "''");
+      return `'${escaped}'`;
+    } else {
+      // Escape double quotes by doubling them
+      const escaped = value.replace(/"/g, '""');
+      return `"${escaped}"`;
+    }
+  } else {
+    // Has colon, parentheses, newlines, or spaces but no quotes
+    return `"${value}"`;
+  }
+}
+
+/**
+ * Format an object as nested Links notation
+ * @param {object} obj - Object to format
+ * @param {number} [indent=2] - Indentation level (spaces)
+ * @param {number} [depth=0] - Current depth
+ * @returns {string} Links notation formatted string
+ */
+function formatAsNestedLinksNotation(obj, indent = 2, depth = 0) {
+  if (obj === null || obj === undefined) {
+    return 'null';
+  }
+
+  if (typeof obj !== 'object') {
+    return escapeForLinksNotation(obj);
+  }
+
+  if (Array.isArray(obj)) {
+    // Format arrays
+    if (obj.length === 0) {
+      return '()';
+    }
+    const indentStr = ' '.repeat(indent * (depth + 1));
+    const items = obj.map((item) => {
+      const formatted = formatAsNestedLinksNotation(item, indent, depth + 1);
+      return `${indentStr}${formatted}`;
+    });
+    return `(\n${items.join('\n')}\n${' '.repeat(indent * depth)})`;
+  }
+
+  // Format objects
+  const entries = Object.entries(obj);
+  if (entries.length === 0) {
+    return '()';
+  }
+
+  const indentStr = ' '.repeat(indent * (depth + 1));
+  const lines = entries
+    .filter(([, value]) => value !== null && value !== undefined)
+    .map(([key, value]) => {
+      if (typeof value === 'object') {
+        const nested = formatAsNestedLinksNotation(value, indent, depth + 1);
+        return `${indentStr}${key}\n${nested}`;
+      }
+      const formattedValue = escapeForLinksNotation(value);
+      return `${indentStr}${key} ${formattedValue}`;
+    });
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  BOX_STYLES,
+  DEFAULT_STYLE,
+  DEFAULT_WIDTH,
+  getBoxStyle,
+  createHorizontalLine,
+  createBorderedLine,
+  createTopBorder,
+  createBottomBorder,
+  createStartBlock,
+  createFinishBlock,
+  formatDuration,
+  escapeForLinksNotation,
+  formatAsNestedLinksNotation,
+};

package/src/lib/status-formatter.js

@@ -7,14 +7,23 @@
  * - Text: Human-readable text format
  */
 
+const {
+  escapeForLinksNotation,
+  formatAsNestedLinksNotation,
+} = require('./output-blocks');
+
 /**
  * Format execution record as Links Notation (indented style)
+ * Uses nested Links notation for object values (like options) instead of JSON
+ *
  * @param {Object} record - The execution record with toObject() method
  * @returns {string} Links Notation formatted string in indented style
  *
  * Output format:
  * <uuid>
  *   <key> "<value>"
+ *   options
+ *     <nested_key> <nested_value>
  *   ...
  */
 function formatRecordAsLinksNotation(record) {
@@ -23,16 +32,27 @@ function formatRecordAsLinksNotation(record) {
 
   for (const [key, value] of Object.entries(obj)) {
     if (value !== null && value !== undefined) {
-      // Format value based on type
-      let formattedValue;
-      if (typeof value === 'object') {
-        formattedValue = JSON.stringify(value);
+      if (key === 'options' && typeof value === 'object') {
+        // Format options as nested Links notation
+        const optionEntries = Object.entries(value).filter(
+          ([, v]) => v !== null && v !== undefined
+        );
+        if (optionEntries.length > 0) {
+          lines.push('  options');
+          for (const [optKey, optValue] of optionEntries) {
+            const formattedOptValue = escapeForLinksNotation(optValue);
+            lines.push(`    ${optKey} ${formattedOptValue}`);
+          }
+        }
+      } else if (typeof value === 'object') {
+        // For other objects, still format as nested Links notation
+        lines.push(`  ${key}`);
+        const nested = formatAsNestedLinksNotation(value, 2, 2);
+        lines.push(nested);
       } else {
-        formattedValue = String(value);
+        const formattedValue = escapeForLinksNotation(value);
+        lines.push(`  ${key} ${formattedValue}`);
       }
-      // Escape quotes in the value
-      const escapedValue = formattedValue.replace(/"/g, '\\"');
-      lines.push(`  ${key} "${escapedValue}"`);
     }
   }
 
@@ -62,8 +82,15 @@ function formatRecordAsText(record) {
     `Log Path:          ${obj.logPath}`,
   ];
 
-  if (Object.keys(obj.options).length > 0) {
-    lines.push(`Options:           ${JSON.stringify(obj.options)}`);
+  // Format options as nested list instead of JSON
+  const optionEntries = Object.entries(obj.options || {}).filter(
+    ([, v]) => v !== null && v !== undefined
+  );
+  if (optionEntries.length > 0) {
+    lines.push(`Options:`);
+    for (const [key, value] of optionEntries) {
+      lines.push(`  ${key}: ${value}`);
+    }
   }
 
   return lines.join('\n');

package/test/output-blocks.test.js

@@ -0,0 +1,197 @@
+/**
+ * Tests for output-blocks module
+ */
+
+const { describe, it, expect } = require('bun:test');
+
+const {
+  BOX_STYLES,
+  DEFAULT_STYLE,
+  DEFAULT_WIDTH,
+  getBoxStyle,
+  createStartBlock,
+  createFinishBlock,
+  formatDuration,
+  escapeForLinksNotation,
+  formatAsNestedLinksNotation,
+} = require('../src/lib/output-blocks');
+
+describe('output-blocks module', () => {
+  describe('BOX_STYLES', () => {
+    it('should have all expected styles', () => {
+      expect(BOX_STYLES).toHaveProperty('rounded');
+      expect(BOX_STYLES).toHaveProperty('heavy');
+      expect(BOX_STYLES).toHaveProperty('double');
+      expect(BOX_STYLES).toHaveProperty('simple');
+      expect(BOX_STYLES).toHaveProperty('ascii');
+    });
+
+    it('should have correct rounded style characters', () => {
+      expect(BOX_STYLES.rounded.topLeft).toBe('╭');
+      expect(BOX_STYLES.rounded.topRight).toBe('╮');
+      expect(BOX_STYLES.rounded.bottomLeft).toBe('╰');
+      expect(BOX_STYLES.rounded.bottomRight).toBe('╯');
+    });
+  });
+
+  describe('getBoxStyle', () => {
+    it('should return rounded style by default', () => {
+      const style = getBoxStyle();
+      expect(style).toEqual(BOX_STYLES.rounded);
+    });
+
+    it('should return requested style', () => {
+      expect(getBoxStyle('heavy')).toEqual(BOX_STYLES.heavy);
+      expect(getBoxStyle('double')).toEqual(BOX_STYLES.double);
+      expect(getBoxStyle('ascii')).toEqual(BOX_STYLES.ascii);
+    });
+
+    it('should return rounded for unknown style', () => {
+      const style = getBoxStyle('unknown');
+      expect(style).toEqual(BOX_STYLES.rounded);
+    });
+  });
+
+  describe('createStartBlock', () => {
+    it('should create a start block with session ID', () => {
+      const block = createStartBlock({
+        sessionId: 'test-uuid-1234',
+        timestamp: '2025-01-01 00:00:00',
+        command: 'echo hello',
+      });
+
+      expect(block).toContain('╭');
+      expect(block).toContain('╰');
+      expect(block).toContain('Session ID: test-uuid-1234');
+      expect(block).toContain('Starting at 2025-01-01 00:00:00: echo hello');
+    });
+
+    it('should use specified style', () => {
+      const block = createStartBlock({
+        sessionId: 'test-uuid',
+        timestamp: '2025-01-01 00:00:00',
+        command: 'echo hello',
+        style: 'ascii',
+      });
+
+      expect(block).toContain('+');
+      expect(block).toContain('-');
+    });
+  });
+
+  describe('createFinishBlock', () => {
+    it('should create a finish block with session ID and exit code', () => {
+      const block = createFinishBlock({
+        sessionId: 'test-uuid-1234',
+        timestamp: '2025-01-01 00:00:01',
+        exitCode: 0,
+        logPath: '/tmp/test.log',
+        durationMs: 17,
+      });
+
+      expect(block).toContain('╭');
+      expect(block).toContain('╰');
+      expect(block).toContain('Session ID: test-uuid-1234');
+      expect(block).toContain(
+        'Finished at 2025-01-01 00:00:01 in 0.017 seconds'
+      );
+      expect(block).toContain('Exit code: 0');
+      expect(block).toContain('Log: /tmp/test.log');
+    });
+
+    it('should create a finish block without duration when not provided', () => {
+      const block = createFinishBlock({
+        sessionId: 'test-uuid-1234',
+        timestamp: '2025-01-01 00:00:01',
+        exitCode: 0,
+        logPath: '/tmp/test.log',
+      });
+
+      expect(block).toContain('Finished at 2025-01-01 00:00:01');
+      expect(block).not.toContain('seconds');
+    });
+  });
+
+  describe('formatDuration', () => {
+    it('should format very small durations', () => {
+      expect(formatDuration(0.5)).toBe('0.001');
+    });
+
+    it('should format millisecond durations', () => {
+      expect(formatDuration(17)).toBe('0.017');
+      expect(formatDuration(500)).toBe('0.500');
+    });
+
+    it('should format second durations', () => {
+      expect(formatDuration(1000)).toBe('1.000');
+      expect(formatDuration(5678)).toBe('5.678');
+    });
+
+    it('should format longer durations with less precision', () => {
+      expect(formatDuration(12345)).toBe('12.35');
+      expect(formatDuration(123456)).toBe('123.5');
+    });
+  });
+
+  describe('escapeForLinksNotation', () => {
+    it('should not quote simple values', () => {
+      expect(escapeForLinksNotation('simple')).toBe('simple');
+      expect(escapeForLinksNotation('123')).toBe('123');
+      expect(escapeForLinksNotation('true')).toBe('true');
+    });
+
+    it('should quote values with spaces', () => {
+      expect(escapeForLinksNotation('hello world')).toBe('"hello world"');
+    });
+
+    it('should quote values with colons', () => {
+      expect(escapeForLinksNotation('key:value')).toBe('"key:value"');
+    });
+
+    it('should use single quotes for values with double quotes', () => {
+      expect(escapeForLinksNotation('say "hello"')).toBe('\'say "hello"\'');
+    });
+
+    it('should use double quotes for values with single quotes', () => {
+      expect(escapeForLinksNotation("it's cool")).toBe('"it\'s cool"');
+    });
+
+    it('should escape quotes when both types are present', () => {
+      const result = escapeForLinksNotation('say "hello" it\'s');
+      // Should wrap in one quote type and escape the other
+      expect(result).toMatch(/^["'].*["']$/);
+    });
+
+    it('should handle null values', () => {
+      expect(escapeForLinksNotation(null)).toBe('null');
+      expect(escapeForLinksNotation(undefined)).toBe('null');
+    });
+  });
+
+  describe('formatAsNestedLinksNotation', () => {
+    it('should format simple objects', () => {
+      const obj = { key: 'value', number: 123 };
+      const result = formatAsNestedLinksNotation(obj);
+
+      expect(result).toContain('key value');
+      expect(result).toContain('number 123');
+    });
+
+    it('should quote values with spaces', () => {
+      const obj = { message: 'hello world' };
+      const result = formatAsNestedLinksNotation(obj);
+
+      expect(result).toContain('message "hello world"');
+    });
+
+    it('should handle empty objects', () => {
+      expect(formatAsNestedLinksNotation({})).toBe('()');
+    });
+
+    it('should handle null', () => {
+      expect(formatAsNestedLinksNotation(null)).toBe('null');
+    });
+  });
+});
+
+console.log('=== Output Blocks Unit Tests ===');

package/test/status-query.test.js

@@ -82,9 +82,10 @@ describe('--status query functionality', () => {
       expect(result.exitCode).toBe(0);
       // Should start with UUID on its own line
       expect(result.stdout).toMatch(new RegExp(`^${testRecord.uuid}\\n`));
-      // Should have indented properties
-      expect(result.stdout).toContain(`  uuid "${testRecord.uuid}"`);
-      expect(result.stdout).toContain('  status "executed"');
+      // Should have indented properties (values without special chars are not quoted)
+      expect(result.stdout).toContain(`  uuid ${testRecord.uuid}`);
+      expect(result.stdout).toContain('  status executed');
+      // Command with space should be quoted
       expect(result.stdout).toContain('  command "echo hello world"');
     });
 
@@ -99,7 +100,8 @@ describe('--status query functionality', () => {
       expect(result.exitCode).toBe(0);
       // Should start with UUID on its own line
       expect(result.stdout).toMatch(new RegExp(`^${testRecord.uuid}\\n`));
-      expect(result.stdout).toContain(`  uuid "${testRecord.uuid}"`);
+      // UUID without special chars is not quoted
+      expect(result.stdout).toContain(`  uuid ${testRecord.uuid}`);
     });
   });