@cnrai/pave 0.3.32 → 0.3.34

package/test/chat-leading-lines.test.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+/**
+ * Behavioral simulation tests for leading empty lines fix (Issue #191)
+ *
+ * These tests simulate the leading-newline stripping logic used in
+ * sendMessageAndStream() to verify correctness of the approach.
+ * They exercise a local reimplementation of the strip logic -- not
+ * the actual production code -- to validate expected behavior for
+ * various delta patterns (LF, CRLF, empty, multi-part).
+ *
+ * Run with: node test/chat-leading-lines.test.js
+ */
+
+let passed = 0;
+let failed = 0;
+
+function runTest(name, testFn) {
+  try {
+    testFn();
+    console.log(`✅ ${name}`);
+    passed++;
+  } catch (error) {
+    console.log(`❌ ${name}: ${error.message}`);
+    failed++;
+  }
+}
+
+function assertEqual(actual, expected, message) {
+  if (actual !== expected) {
+    throw new Error(`${message}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
+
+// ============================================================
+// Behavioral verification
+// ============================================================
+
+/**
+ * Simulate the streaming output accumulation with the fix applied.
+ * This mirrors the logic in sendMessageAndStream() (issue #191).
+ * Uses /^[\r\n]+/ to handle both LF and CRLF.
+ */
+function simulateStreamOutput(deltas) {
+  let fullResponse = '';
+  const output = [];
+
+  for (const delta of deltas) {
+    let outputText = delta;
+    // Strip leading newlines from first output (issue #191)
+    if (fullResponse.length === 0) {
+      outputText = outputText.replace(/^[\r\n]+/, '');
+    }
+    if (outputText) {
+      output.push(outputText);
+      fullResponse += outputText;
+    }
+  }
+
+  return { fullResponse, output };
+}
+
+/**
+ * Simulate the final render/JSON trim path.
+ */
+function simulateRenderTrim(fullResponse) {
+  return fullResponse.replace(/^[\r\n]+/, '');
+}
+
+// --- Streaming delta tests ---
+
+runTest('single delta with leading LF newlines: newlines stripped', () => {
+  const result = simulateStreamOutput(['\n\nHello world']);
+  assertEqual(result.fullResponse, 'Hello world', 'fullResponse');
+  assertEqual(result.output.length, 1, 'output chunk count');
+  assertEqual(result.output[0], 'Hello world', 'output chunk');
+});
+
+runTest('single delta with leading CRLF: stripped', () => {
+  const result = simulateStreamOutput(['\r\n\r\nHello world']);
+  assertEqual(result.fullResponse, 'Hello world', 'fullResponse');
+  assertEqual(result.output[0], 'Hello world', 'output chunk');
+});
+
+runTest('multiple deltas with leading newlines on first: only first stripped', () => {
+  const result = simulateStreamOutput(['\n\n', 'Hello', '\n\n', 'world']);
+  // First delta is all newlines -> stripped to empty -> skipped
+  // Second delta: fullResponse is still empty, no leading newlines -> added
+  assertEqual(result.fullResponse, 'Hello\n\nworld', 'fullResponse');
+  assertEqual(result.output.length, 3, 'output chunk count');
+});
+
+runTest('delta without leading newlines: unchanged', () => {
+  const result = simulateStreamOutput(['Hello world']);
+  assertEqual(result.fullResponse, 'Hello world', 'fullResponse');
+  assertEqual(result.output[0], 'Hello world', 'output chunk');
+});
+
+runTest('empty delta: skipped', () => {
+  const result = simulateStreamOutput(['', 'Hello']);
+  assertEqual(result.fullResponse, 'Hello', 'fullResponse');
+  assertEqual(result.output.length, 1, 'output chunk count');
+});
+
+runTest('newlines after first content: preserved', () => {
+  const result = simulateStreamOutput(['Hello', '\n\n', 'World']);
+  assertEqual(result.fullResponse, 'Hello\n\nWorld', 'fullResponse');
+  assertEqual(result.output.length, 3, 'output chunk count');
+});
+
+runTest('leading newlines only on first delta of multi-part: stripped', () => {
+  const result = simulateStreamOutput(['\nFirst line', '\nSecond part']);
+  assertEqual(result.fullResponse, 'First line\nSecond part', 'fullResponse');
+});
+
+runTest('all newlines delta followed by text: newlines skipped, text preserved', () => {
+  const result = simulateStreamOutput(['\n\n\n', 'Content here']);
+  assertEqual(result.fullResponse, 'Content here', 'fullResponse');
+});
+
+runTest('content with only newlines: results in empty output', () => {
+  const result = simulateStreamOutput(['\n\n\n']);
+  assertEqual(result.fullResponse, '', 'fullResponse should be empty');
+  assertEqual(result.output.length, 0, 'no output chunks');
+});
+
+runTest('mixed CR and LF: all stripped from first delta', () => {
+  const result = simulateStreamOutput(['\r\n\n\r\nContent']);
+  assertEqual(result.fullResponse, 'Content', 'fullResponse');
+});
+
+// --- Final render/JSON trim tests ---
+
+runTest('render trim: fullResponse with leading LF newlines trimmed', () => {
+  assertEqual(simulateRenderTrim('\n\nRendered content'), 'Rendered content', 'trimmed');
+});
+
+runTest('render trim: fullResponse with leading CRLF trimmed', () => {
+  assertEqual(simulateRenderTrim('\r\n\r\nRendered content'), 'Rendered content', 'trimmed');
+});
+
+runTest('render trim: no leading newlines unchanged', () => {
+  assertEqual(simulateRenderTrim('Already clean'), 'Already clean', 'unchanged');
+});
+
+runTest('JSON output trim: response field has no leading newlines', () => {
+  const output = { response: simulateRenderTrim('\n\nJSON response content') };
+  assertEqual(output.response, 'JSON response content', 'JSON response');
+});
+
+runTest('render trim: preserves internal newlines', () => {
+  assertEqual(simulateRenderTrim('\n\nLine 1\n\nLine 2'), 'Line 1\n\nLine 2', 'internal preserved');
+});
+
+// ============================================================
+console.log(`\nResults: ${passed} passed, ${failed} failed`);
+
+if (failed > 0) {
+  throw new Error(`${failed} chat-leading-lines test(s) failed`);
+}

package/test/config-flag.test.js

@@ -0,0 +1,272 @@
+/**
+ * Tests for --config flag effectiveness across all pave commands (issue #126).
+ *
+ * Verifies:
+ * 1. Legacy constants removed from skill-manager.js and marketplace.js
+ * 2. parseArgs() commandArgs doesn't leak --config values (behavioral)
+ * 3. setPaveHome correctly updates getPaths()/getCachePaths() (behavioral)
+ * 4. No hardcoded ~/.pave in token configuration message
+ *
+ * Uses checkmark/X format so run-all.js correctly counts results.
+ */
+
+let passed = 0;
+let failed = 0;
+
+function assert(cond, msg) {
+  if (cond) {
+    passed++;
+    console.log('\u2705 ' + msg);
+  } else {
+    failed++;
+    console.log('\u274c ' + msg);
+  }
+}
+
+const fs = require('fs');
+const path = require('path');
+const child_process = require('child_process');
+const os = require('os');
+
+const projDir = path.resolve(__dirname, '../../../..');
+
+// Helper to run a script via temp file (sandbox blocks node -e)
+function runScript(code) {
+  const tmp = path.join(projDir, '_test_tmp_' + Date.now() + '.js');
+  try {
+    fs.writeFileSync(tmp, code, 'utf8');
+    const out = child_process.execFileSync(process.execPath, [tmp], {
+      cwd: projDir, encoding: 'utf8', timeout: 5000,
+    }).trim();
+    return JSON.parse(out);
+  } catch (e) {
+    // Log the error so regressions aren't silently hidden
+    console.log('SKIP (subprocess error): ' + (e.stderr || e.message || '').slice(0, 120));
+    return null;
+  } finally {
+    try { fs.unlinkSync(tmp); } catch (e2) {}
+  }
+}
+
+// ---- 1. Behavioral test: parseArgs() commandArgs handling ----
+function testParseArgs(argv) {
+  return runScript(
+    'var p = require("./src/packages/pave/lib/args-parser").parseArgs;\n' +
+    'var r = p(' + JSON.stringify(argv) + ');\n' +
+    'console.log(JSON.stringify({command:r.command,config:r.config,commandArgs:r.commandArgs}));\n',
+  );
+}
+
+const r1 = testParseArgs(['list', '--config', './.pave']);
+if (r1) {
+  assert(r1.command === 'list', 'parseArgs: list command detected');
+  assert(r1.config === './.pave', 'parseArgs: --config value parsed');
+  assert(r1.commandArgs.indexOf('./.pave') === -1, 'parseArgs: ./.pave NOT in commandArgs');
+  assert(r1.commandArgs.length === 0, 'parseArgs: commandArgs empty for list --config');
+} else {
+  console.log('SKIP: parseArgs test via subprocess not available');
+}
+
+const tmpPave = path.join(os.tmpdir(), '.pave');
+const r2 = testParseArgs(['install', 'gmail', '--config', tmpPave]);
+if (r2) {
+  assert(r2.config === tmpPave, 'parseArgs: --config value parsed for install');
+  assert(r2.commandArgs.indexOf(tmpPave) === -1, 'parseArgs: config path NOT in install commandArgs');
+  assert(r2.commandArgs.length === 1 && r2.commandArgs[0] === 'gmail',
+    'parseArgs: install commandArgs = [gmail]');
+}
+
+const r3 = testParseArgs(['remove', 'my-skill', '--config', './.pave']);
+if (r3) {
+  assert(r3.commandArgs.indexOf('./.pave') === -1, 'parseArgs: ./.pave NOT in remove commandArgs');
+  assert(r3.commandArgs[0] === 'my-skill', 'parseArgs: remove commandArgs = [my-skill]');
+}
+
+const r4 = testParseArgs(['search', 'query', '--category', 'tools', '--config', '/custom']);
+if (r4) {
+  assert(r4.commandArgs.indexOf('/custom') === -1, 'parseArgs: /custom NOT in search commandArgs');
+  assert(r4.commandArgs.indexOf('tools') === -1, 'parseArgs: --category value NOT in commandArgs');
+  assert(r4.commandArgs[0] === 'query', 'parseArgs: search commandArgs = [query]');
+}
+
+const r5 = testParseArgs(['update', '--config', './.pave']);
+if (r5) {
+  assert(r5.commandArgs.length === 0, 'parseArgs: update commandArgs empty');
+}
+
+// Test flags Copilot specifically requested coverage for
+const r6 = testParseArgs(['list', '--bind', '0.0.0.0', '--config', './.pave']);
+if (r6) {
+  assert(r6.commandArgs.indexOf('0.0.0.0') === -1, 'parseArgs: --bind value NOT in commandArgs');
+}
+
+const r7 = testParseArgs(['list', '-b', '0.0.0.0']);
+if (r7) {
+  assert(r7.commandArgs.indexOf('0.0.0.0') === -1, 'parseArgs: -b value NOT in commandArgs');
+}
+
+const r8 = testParseArgs(['list', '--shell', '/bin/bash']);
+if (r8) {
+  assert(r8.commandArgs.indexOf('/bin/bash') === -1, 'parseArgs: --shell value NOT in commandArgs');
+}
+
+const r9 = testParseArgs(['list', '--last', '5']);
+if (r9) {
+  assert(r9.commandArgs.indexOf('5') === -1, 'parseArgs: --last value NOT in commandArgs');
+}
+
+const r10 = testParseArgs(['list', '--export', 'out.md']);
+if (r10) {
+  assert(r10.commandArgs.indexOf('out.md') === -1, 'parseArgs: --export value NOT in commandArgs');
+}
+
+const r11 = testParseArgs(['install', 'a', 'b', '--config', './.pave']);
+if (r11) {
+  assert(r11.commandArgs.length === 2, 'parseArgs: install a b -> 2 commandArgs');
+  assert(r11.commandArgs[0] === 'a' && r11.commandArgs[1] === 'b',
+    'parseArgs: install commandArgs = [a, b]');
+}
+
+// Optional-value flags: --ish-mode and --memory-monitor should not leak values
+const r13 = testParseArgs(['list', '--ish-mode', 'true']);
+if (r13) {
+  assert(r13.commandArgs.indexOf('true') === -1, 'parseArgs: --ish-mode value NOT in commandArgs');
+  assert(r13.commandArgs.length === 0, 'parseArgs: list --ish-mode true -> empty commandArgs');
+}
+
+const r14 = testParseArgs(['list', '--memory-monitor', 'off']);
+if (r14) {
+  assert(r14.commandArgs.indexOf('off') === -1, 'parseArgs: --memory-monitor value NOT in commandArgs');
+  assert(r14.commandArgs.length === 0, 'parseArgs: list --memory-monitor off -> empty commandArgs');
+}
+
+// --ish-mode without a recognized value should not consume next token
+const r15 = testParseArgs(['install', '--ish-mode', 'gmail']);
+if (r15) {
+  assert(r15.commandArgs.length === 1 && r15.commandArgs[0] === 'gmail',
+    'parseArgs: --ish-mode without value -> gmail stays in commandArgs');
+}
+
+// --config at end (missing value) - must run in subprocess since parseArgs calls process.exit(1)
+const configMissingScript = [
+  'var p = require("./src/packages/pave/lib/args-parser").parseArgs;',
+  'p(["list", "--config"]);',
+  'console.log(JSON.stringify({ok:true}));',
+].join('\n');
+const tmpMissing = path.join(projDir, '_test_tmp_missing_' + Date.now() + '.js');
+try {
+  fs.writeFileSync(tmpMissing, configMissingScript, 'utf8');
+  const child = child_process.spawnSync(process.execPath, [tmpMissing], {
+    cwd: projDir, encoding: 'utf8', timeout: 5000, stdio: 'pipe',
+  });
+  assert(child.status !== 0, 'parseArgs: --config at end -> non-zero exit');
+  // When running in a real Node.js environment (not sandbox), verify error message
+  const stderr = child.stderr || '';
+  if (stderr.indexOf('--config') !== -1) {
+    assert(true, 'parseArgs: --config at end -> error mentions --config');
+  }
+} catch (e) {
+  assert(false, 'parseArgs: --config at end -> subprocess failed: ' + e.message);
+} finally {
+  try { fs.unlinkSync(tmpMissing); } catch (e2) {}
+}
+
+// ---- 2. Behavioral test: setPaveHome / getPaths ----
+const ph = runScript([
+  'var os = require("os");',
+  'var path = require("path");',
+  'var sm = require("./src/packages/pave/lib/skill-manager");',
+  'var mp = require("./src/packages/pave/lib/marketplace");',
+  'var testDir = path.join(os.tmpdir(), "test-pave-cfg");',
+  'sm.setPaveHome(testDir);',
+  'mp.setPaveHome(testDir);',
+  'var p = sm.getPaths();',
+  'var c = mp.getCachePaths();',
+  'console.log(JSON.stringify({',
+  '  skillsDir: p.skillsDir,',
+  '  lockFile: p.lockFile,',
+  '  permissionsFile: p.permissionsFile,',
+  '  cacheDir: c.cacheDir,',
+  '  cacheFile: c.cacheFile,',
+  '  testDir: testDir,',
+  '  hasSKILLS_DIR: typeof sm.SKILLS_DIR !== "undefined",',
+  '  hasLOCK_FILE: typeof sm.LOCK_FILE !== "undefined",',
+  '  hasCACHE_DIR: typeof mp.CACHE_DIR !== "undefined",',
+  '  hasCACHE_FILE: typeof mp.CACHE_FILE !== "undefined",',
+  '  skillsDirIsDynamic: sm.SKILLS_DIR === sm.getPaths().skillsDir,',
+  '  lockFileIsDynamic: sm.LOCK_FILE === sm.getPaths().lockFile,',
+  '  cacheDirIsDynamic: mp.CACHE_DIR === mp.getCachePaths().cacheDir,',
+  '  cacheFileIsDynamic: mp.CACHE_FILE === mp.getCachePaths().cacheFile',
+  '}));',
+].join('\n'));
+
+if (ph) {
+  assert(ph.skillsDir.indexOf(ph.testDir) !== -1,
+    'setPaveHome: skillsDir uses custom path');
+  assert(ph.lockFile.indexOf(ph.testDir) !== -1,
+    'setPaveHome: lockFile uses custom path');
+  assert(ph.permissionsFile.indexOf(ph.testDir) !== -1,
+    'setPaveHome: permissionsFile uses custom path');
+  assert(ph.cacheDir.indexOf(ph.testDir) !== -1,
+    'setPaveHome: cacheDir uses custom path');
+  assert(ph.cacheFile.indexOf(ph.testDir) !== -1,
+    'setPaveHome: cacheFile uses custom path');
+  assert(ph.hasSKILLS_DIR === true, 'export: SKILLS_DIR available as deprecated getter');
+  assert(ph.hasLOCK_FILE === true, 'export: LOCK_FILE available as deprecated getter');
+  assert(ph.hasCACHE_DIR === true, 'export: CACHE_DIR available as deprecated getter');
+  assert(ph.hasCACHE_FILE === true, 'export: CACHE_FILE available as deprecated getter');
+  assert(ph.skillsDirIsDynamic === true, 'export: SKILLS_DIR delegates to getPaths()');
+  assert(ph.lockFileIsDynamic === true, 'export: LOCK_FILE delegates to getPaths()');
+  assert(ph.cacheDirIsDynamic === true, 'export: CACHE_DIR delegates to getCachePaths()');
+  assert(ph.cacheFileIsDynamic === true, 'export: CACHE_FILE delegates to getCachePaths()');
+} else {
+  console.log('SKIP: setPaveHome subprocess not available');
+}
+
+// ---- 3. Source check: no hardcoded ~/.pave in token message ----
+const ixSrc = fs.readFileSync(path.resolve(__dirname, '../index.js'), 'utf8');
+assert(!/Configure tokens in ~\/.pave/.test(ixSrc),
+  'index.js: no hardcoded ~/.pave in token message');
+assert(/getPaveHome\(\).*tokens\.yaml/.test(ixSrc),
+  'index.js: getPaveHome() used for tokens path');
+
+// ---- 4. Source check: legacy constants removed ----
+const smSrc = fs.readFileSync(path.resolve(__dirname, '../lib/skill-manager.js'), 'utf8');
+const mpSrc = fs.readFileSync(path.resolve(__dirname, '../lib/marketplace.js'), 'utf8');
+
+assert(!/^const SKILLS_DIR\b/m.test(smSrc),
+  'source: no hardcoded SKILLS_DIR constant in skill-manager.js');
+assert(!/^const LOCK_FILE\b/m.test(smSrc),
+  'source: no hardcoded LOCK_FILE constant in skill-manager.js');
+assert(!/^const CACHE_DIR\b/m.test(mpSrc),
+  'source: no hardcoded CACHE_DIR constant in marketplace.js');
+assert(!/^const CACHE_FILE\b/m.test(mpSrc),
+  'source: no hardcoded CACHE_FILE constant in marketplace.js');
+assert(!/^const CACHE_META_FILE\b/m.test(mpSrc),
+  'source: no hardcoded CACHE_META_FILE constant in marketplace.js');
+// Verify deprecated getters delegate to getPaths()/getCachePaths()
+assert(/get SKILLS_DIR/.test(smSrc),
+  'source: SKILLS_DIR is a deprecated getter in skill-manager.js');
+assert(/get LOCK_FILE/.test(smSrc),
+  'source: LOCK_FILE is a deprecated getter in skill-manager.js');
+assert(/get CACHE_DIR/.test(mpSrc),
+  'source: CACHE_DIR is a deprecated getter in marketplace.js');
+assert(/get CACHE_FILE/.test(mpSrc),
+  'source: CACHE_FILE is a deprecated getter in marketplace.js');
+
+// ---- 5. Source check: flagsWithValues completeness ----
+const apSrc = fs.readFileSync(path.resolve(__dirname, '../lib/args-parser.js'), 'utf8');
+assert(/FLAGS_WITH_VALUES/.test(apSrc), 'args-parser: FLAGS_WITH_VALUES set exists at module scope');
+assert(/'--bind'/.test(apSrc) && /'-b'/.test(apSrc), 'args-parser: --bind/-b in FLAGS_WITH_VALUES');
+assert(/'--shell'/.test(apSrc), 'args-parser: --shell in FLAGS_WITH_VALUES');
+assert(/'--last'/.test(apSrc), 'args-parser: --last in FLAGS_WITH_VALUES');
+assert(/'--export'/.test(apSrc), 'args-parser: --export in FLAGS_WITH_VALUES');
+assert(/OPTIONAL_VALUE_FLAGS/.test(apSrc), 'args-parser: OPTIONAL_VALUE_FLAGS set exists');
+assert(/'--ish-mode'/.test(apSrc), 'args-parser: --ish-mode in OPTIONAL_VALUE_FLAGS');
+assert(/'--memory-monitor'/.test(apSrc), 'args-parser: --memory-monitor in OPTIONAL_VALUE_FLAGS');
+
+console.log('');
+console.log(passed + ' passed, ' + failed + ' failed');
+if (failed > 0) throw new Error(failed + ' test(s) failed');
+
+// trigger

package/test/cursor-drift.test.js

@@ -0,0 +1,135 @@
+/**
+ * Tests for chatbar cursor drift fix (issue #112).
+ *
+ * Cursor math simulation verifying that wrapping at wrapWidth (widgetWidth-1)
+ * matching blessed's textarea margin eliminates cursor drift.
+ *
+ * Blessed's _wrapContent only wraps when line.length > width (not >=),
+ * so at exact multiples of wrapWidth the cursor stays on the same line
+ * at col === wrapWidth (the textarea margin column).
+ *
+ * Uses checkmark/X format so run-all.js correctly counts results.
+ */
+
+let passed = 0;
+let failed = 0;
+
+function assert(cond, msg) {
+  if (cond) {
+    passed++;
+    console.log('\u2705 ' + msg);
+  } else {
+    failed++;
+    console.log('\u274c ' + msg);
+  }
+}
+
+// ---- Cursor math simulation ----
+// Blessed wraps when length > width, NOT when length >= width.
+// So at exact multiples, cursor stays at col=wrapWidth on previous line.
+function simWrap(textLen, wrapWidth) {
+  if (textLen <= 0) return { wraps: 0, col: 0 };
+  const wraps = Math.floor((textLen - 1) / wrapWidth);
+  const col = ((textLen - 1) % wrapWidth) + 1;
+  return { wraps, col };
+}
+
+// Simulate a widget with raw width 42 (xl-xi=42, iwidth=2 -> widgetWidth=40)
+// wrapWidth = widgetWidth - 1 = 39 (matches blessed textarea margin)
+const widgetWidth = 40;
+const wrapWidth = widgetWidth - 1; // 39
+
+// Page 1: within first page
+const r20 = simWrap(20, wrapWidth);
+assert(r20.col === 20 && r20.wraps === 0, 'page 1: col 20 at 20 chars');
+
+// Right at wrapWidth boundary (39 chars)  blessed does NOT wrap here
+const r39 = simWrap(39, wrapWidth);
+assert(r39.col === 39 && r39.wraps === 0, 'at wrapWidth: col 39, no wrap (blessed textarea margin)');
+
+// One past wrapWidth (40 chars)  blessed wraps here
+const r40 = simWrap(40, wrapWidth);
+assert(r40.col === 1 && r40.wraps === 1, 'past wrapWidth: col 1, wraps to line 2');
+
+// At 2*wrapWidth (78 chars)  exact multiple, no extra wrap
+const r78 = simWrap(78, wrapWidth);
+assert(r78.col === 39 && r78.wraps === 1, 'at 2*wrapWidth: col 39, stays on line 2');
+
+// At 2*wrapWidth + 1 (79 chars)  wraps
+const r79 = simWrap(79, wrapWidth);
+assert(r79.col === 1 && r79.wraps === 2, 'past 2*wrapWidth: col 1, wraps to line 3');
+
+// 80 chars
+const r80 = simWrap(80, wrapWidth);
+assert(r80.col === 2 && r80.wraps === 2, '80 chars: col 2, 2 wraps');
+
+// ---- Verify old code drifts but new code does not ----
+// Old code: wraps at widgetWidth (40), uses Math.floor(len/40)
+function simOld(textLen, w) {
+  return { wraps: Math.floor(textLen / w), col: textLen % w };
+}
+
+const oldAt39 = simOld(39, 40);
+const newAt39 = simWrap(39, 39);
+assert(newAt39.wraps === 0 && newAt39.col === 39,
+  'new code: 39 chars stays on line 1 at col 39');
+assert(oldAt39.wraps === 0 && oldAt39.col === 39,
+  'old code: 39 chars also on line 1 (no drift yet)');
+
+const oldAt78 = simOld(78, 40);
+const newAt78 = simWrap(78, 39);
+assert(newAt78.wraps === 1 && newAt78.col === 39,
+  'new code: 78 chars on line 2, col 39');
+assert(oldAt78.wraps === 1 && oldAt78.col === 38,
+  'old code: 78 chars on line 2, col 38 (drift of 1)');
+
+// ---- Edge cases ----
+// Empty text
+const empty = simWrap(0, 39);
+assert(empty.col === 0 && empty.wraps === 0, 'empty text: col 0, no wraps');
+
+// Exactly 1 char
+const one = simWrap(1, 39);
+assert(one.col === 1 && one.wraps === 0, '1 char: col 1, no wraps');
+
+// Width of 1 (minimum after guard)
+const narrow = simWrap(5, 1);
+assert(narrow.wraps === 4 && narrow.col === 1, 'width=1: 5 chars -> 4 wraps, col 1');
+
+// Very long text
+const longText = simWrap(1000, 39);
+assert(longText.wraps === 25 && longText.col === 25, '1000 chars at width 39: 25 wraps, col 25');
+
+// ---- wrapWidth guard: ensure wrapWidth < 1 is clamped to 1 ----
+function simClampedWrapWidth(widgetW) {
+  let ww = widgetW - 1;
+  if (ww < 1) ww = 1;
+  return ww;
+}
+assert(simClampedWrapWidth(1) === 1, 'wrapWidth guard: widgetWidth=1 -> wrapWidth=1');
+assert(simClampedWrapWidth(0) === 1, 'wrapWidth guard: widgetWidth=0 -> wrapWidth=1');
+assert(simClampedWrapWidth(2) === 1, 'wrapWidth guard: widgetWidth=2 -> wrapWidth=1');
+assert(simClampedWrapWidth(40) === 39, 'wrapWidth guard: widgetWidth=40 -> wrapWidth=39');
+
+// ---- Cumulative drift test across many wrap boundaries ----
+// With blessed's behavior, at exact multiples of wrapWidth the cursor
+// stays at col=wrapWidth on the previous visual line, NOT at col=0
+// on the next line. This is the regression test for issue #112.
+for (let p = 1; p <= 20; p++) {
+  const chars = p * 39;
+  const result = simWrap(chars, 39);
+  assert(result.col === 39 && result.wraps === p - 1,
+    'no cumulative drift at boundary ' + p + ' (' + chars + ' chars): col=39, wraps=' + (p - 1));
+}
+
+// ---- Wrap only happens when EXCEEDING wrapWidth ----
+for (let p = 1; p <= 10; p++) {
+  const chars = p * 39 + 1; // one past boundary
+  const result = simWrap(chars, 39);
+  assert(result.col === 1 && result.wraps === p,
+    'wrap at boundary+1 ' + p + ' (' + chars + ' chars): col=1, wraps=' + p);
+}
+
+console.log('');
+console.log(passed + ' passed, ' + failed + ' failed');
+if (failed > 0) throw new Error(failed + ' test(s) failed');

package/test/debug-require.js

@@ -0,0 +1,23 @@
+// Debug script to test require paths
+const path = require('path');
+const fs = require('fs');
+
+console.log('Current directory:', __dirname);
+console.log('Test files:', fs.readdirSync(__dirname).filter((f) => f.endsWith('.test.js')));
+
+const testFile = path.join(__dirname, 'integration.test.js');
+console.log('\nTest file path:', testFile);
+console.log('File exists:', fs.existsSync(testFile));
+
+// Try to require the args-parser
+const argsParserPath = path.join(__dirname, '../lib/args-parser.js');
+console.log('\nArgs-parser path:', argsParserPath);
+console.log('Args-parser exists:', fs.existsSync(argsParserPath));
+
+try {
+  const argsParser = require(argsParserPath);
+  console.log('Args-parser loaded successfully');
+  console.log('Exports:', Object.keys(argsParser));
+} catch (error) {
+  console.error('Failed to load args-parser:', error.message);
+}