opencode-dux 1.0.0

package/src/utils/system-collapse.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, test } from 'bun:test';
+import { collapseSystemInPlace } from './system-collapse';
+
+/**
+ * Regression tests for the system message collapse logic.
+ *
+ * PR #336's collapse was a silent no-op because it reassigned
+ * output.system to a new array, but OpenCode core reads from the
+ * original array reference. The fix mutates in-place.
+ *
+ * These tests import the actual shared function used by the hook,
+ * so any regression in the implementation is caught immediately.
+ */
+
+describe('collapseSystemInPlace', () => {
+  test('mutates multi-element array in-place', () => {
+    const system = ['part one', 'part two'];
+    const output = { system };
+
+    collapseSystemInPlace(output.system);
+
+    // Same reference - callers holding the original array see the change
+    expect(output.system).toBe(system);
+    expect(system).toHaveLength(1);
+    expect(system[0]).toBe('part one\n\npart two');
+  });
+
+  test('mutates three-element array in-place', () => {
+    const system = ['header', 'todo reminder', 'file nudge'];
+    const output = { system };
+
+    collapseSystemInPlace(output.system);
+
+    expect(output.system).toBe(system);
+    expect(system).toHaveLength(1);
+    expect(system[0]).toBe('header\n\ntodo reminder\n\nfile nudge');
+  });
+
+  test('handles single-element array', () => {
+    const system = ['only element'];
+    const output = { system };
+
+    collapseSystemInPlace(output.system);
+
+    expect(output.system).toBe(system);
+    expect(system).toHaveLength(1);
+    expect(system[0]).toBe('only element');
+  });
+
+  test('handles empty array', () => {
+    const system: string[] = [];
+    const output = { system };
+
+    collapseSystemInPlace(output.system);
+
+    expect(output.system).toBe(system);
+    expect(system).toHaveLength(0);
+  });
+
+  test('preserves previous empty-string cleanup behavior', () => {
+    const system = [''];
+    const output = { system };
+
+    collapseSystemInPlace(output.system);
+
+    expect(output.system).toBe(system);
+    expect(system).toHaveLength(0);
+  });
+
+  test('reassignment would NOT be visible (regression guard)', () => {
+    // This test documents WHY we mutate in-place and not via reassignment.
+    // Simulating the broken PR #336 approach to prove it fails.
+    const system = ['a', 'b'];
+    const output = { system };
+
+    // Broken approach: reassign the property
+    output.system = [output.system.join('\n\n')];
+
+    // The output object sees the new array...
+    expect(output.system).toEqual(['a\n\nb']);
+
+    // ...but the original reference is untouched - this is the bug.
+    expect(system).toEqual(['a', 'b']);
+    expect(system).not.toBe(output.system);
+  });
+});

package/src/utils/system-collapse.ts

@@ -0,0 +1,24 @@
+/**
+ * Collapse a system message array into a single element by joining all
+ * entries with double-newline separators. Mutates the array in-place so
+ * that callers holding a reference to the original array see the change.
+ */
+export function collapseSystemInPlace(system: string[]): void {
+  if (system.length === 0) {
+    return;
+  }
+
+  if (system.length === 1) {
+    if (system[0]) {
+      return;
+    }
+    system.length = 0;
+    return;
+  }
+
+  const joined = system.join('\n\n');
+  system.length = 0;
+  if (joined) {
+    system.push(joined);
+  }
+}

package/src/utils/task.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from 'bun:test';
+import { parseTaskIdFromTaskOutput } from './task';
+
+describe('parseTaskIdFromTaskOutput', () => {
+  test('parses task_id line from successful task tool output', () => {
+    const output = [
+      'task_id: session-abc-123 (for resuming to continue this task if needed)',
+      '',
+      '<task_result>',
+      'done',
+      '</task_result>',
+    ].join('\n');
+
+    expect(parseTaskIdFromTaskOutput(output)).toBe('session-abc-123');
+  });
+
+  test('returns undefined when task_id is absent', () => {
+    const output = ['<task_result>', 'no task id here', '</task_result>'].join(
+      '\n',
+    );
+
+    expect(parseTaskIdFromTaskOutput(output)).toBeUndefined();
+  });
+});

package/src/utils/task.ts

@@ -0,0 +1,20 @@
+/**
+ * Parse Task tool output to recover a session/task ID for resumption.
+ */
+
+export function parseTaskIdFromTaskOutput(output: string): string | undefined {
+  const lines = output.split(/\r?\n/);
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const match = /^task_id:\s*([^\s()]+)(?:\s*\(.*)?$/.exec(trimmed);
+
+    if (!match) {
+      continue;
+    }
+
+    return match[1];
+  }
+
+  return undefined;
+}

package/src/utils/zip-extractor.ts

@@ -0,0 +1,102 @@
+import { spawnSync } from 'node:child_process';
+import { release } from 'node:os';
+import { crossSpawn } from './compat';
+
+const WINDOWS_BUILD_WITH_TAR = 17134;
+
+function getWindowsBuildNumber(): number | null {
+  if (process.platform !== 'win32') return null;
+
+  const parts = release().split('.');
+  if (parts.length >= 3) {
+    const build = parseInt(parts[2], 10);
+    if (!Number.isNaN(build)) return build;
+  }
+  return null;
+}
+
+function isPwshAvailable(): boolean {
+  if (process.platform !== 'win32') return false;
+  const result = spawnSync('where', ['pwsh'], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  return result.status === 0;
+}
+
+function escapePowerShellPath(path: string): string {
+  return path.replace(/'/g, "''");
+}
+
+type WindowsZipExtractor = 'tar' | 'pwsh' | 'powershell';
+
+function getWindowsZipExtractor(): WindowsZipExtractor {
+  const buildNumber = getWindowsBuildNumber();
+
+  if (buildNumber !== null && buildNumber >= WINDOWS_BUILD_WITH_TAR) {
+    return 'tar';
+  }
+
+  if (isPwshAvailable()) {
+    return 'pwsh';
+  }
+
+  return 'powershell';
+}
+
+export async function extractZip(
+  archivePath: string,
+  destDir: string,
+): Promise<void> {
+  let proc: ReturnType<typeof crossSpawn>;
+
+  if (process.platform === 'win32') {
+    const extractor = getWindowsZipExtractor();
+
+    switch (extractor) {
+      case 'tar':
+        proc = crossSpawn(['tar', '-xf', archivePath, '-C', destDir], {
+          stdout: 'ignore',
+          stderr: 'pipe',
+        });
+        break;
+      case 'pwsh':
+        proc = crossSpawn(
+          [
+            'pwsh',
+            '-Command',
+            `Expand-Archive -Path '${escapePowerShellPath(archivePath)}' -DestinationPath '${escapePowerShellPath(destDir)}' -Force`,
+          ],
+          {
+            stdout: 'ignore',
+            stderr: 'pipe',
+          },
+        );
+        break;
+      default:
+        proc = crossSpawn(
+          [
+            'powershell',
+            '-Command',
+            `Expand-Archive -Path '${escapePowerShellPath(archivePath)}' -DestinationPath '${escapePowerShellPath(destDir)}' -Force`,
+          ],
+          {
+            stdout: 'ignore',
+            stderr: 'pipe',
+          },
+        );
+        break;
+    }
+  } else {
+    proc = crossSpawn(['unzip', '-o', archivePath, '-d', destDir], {
+      stdout: 'ignore',
+      stderr: 'pipe',
+    });
+  }
+
+  const exitCode = await proc.exited;
+
+  if (exitCode !== 0) {
+    const stderr = await proc.stderr();
+    throw new Error(`zip extraction failed (exit ${exitCode}): ${stderr}`);
+  }
+}