opencode-dux 1.0.0

package/src/utils/session-manager.test.ts

@@ -0,0 +1,173 @@
+import { describe, expect, test } from 'bun:test';
+import { deriveTaskSessionLabel, SessionManager } from './session-manager';
+
+describe('SessionManager', () => {
+  test('keeps most recently used sessions within limit', () => {
+    const manager = new SessionManager(2);
+
+    manager.remember({
+      parentSessionId: 'parent-1',
+      taskId: 'task-1',
+      agentType: 'explorer',
+      label: 'first thread',
+    });
+    manager.remember({
+      parentSessionId: 'parent-1',
+      taskId: 'task-2',
+      agentType: 'explorer',
+      label: 'second thread',
+    });
+    manager.markUsed('parent-1', 'explorer', 'task-1');
+    manager.remember({
+      parentSessionId: 'parent-1',
+      taskId: 'task-3',
+      agentType: 'explorer',
+      label: 'third thread',
+    });
+
+    const prompt = manager.formatForPrompt('parent-1');
+    expect(prompt).toContain('exp-1 first thread');
+    expect(prompt).toContain('exp-3 third thread');
+    expect(prompt).not.toContain('exp-2 second thread');
+  });
+
+  test('clears parent-scoped sessions', () => {
+    const manager = new SessionManager(2);
+
+    manager.remember({
+      parentSessionId: 'parent-1',
+      taskId: 'task-1',
+      agentType: 'oracle',
+      label: 'architecture',
+    });
+
+    manager.clearParent('parent-1');
+
+    expect(manager.formatForPrompt('parent-1')).toBeUndefined();
+  });
+
+  test('includes read context for remembered sessions', () => {
+    const manager = new SessionManager(2);
+
+    manager.remember({
+      parentSessionId: 'parent-1',
+      taskId: 'task-1',
+      agentType: 'explorer',
+      label: 'session manager',
+    });
+    manager.addContext('task-1', [
+      { path: 'src/index.ts', lineCount: 42, lastReadAt: 1 },
+    ]);
+
+    const prompt = manager.formatForPrompt('parent-1');
+    expect(prompt).toContain('exp-1 session manager');
+    expect(prompt).toContain(
+      'Context read by exp-1: src/index.ts (42 lines)',
+    );
+  });
+
+  test('filters tiny reads and caps read context files', () => {
+    const manager = new SessionManager(2);
+
+    manager.remember({
+      parentSessionId: 'parent-1',
+      taskId: 'task-1',
+      agentType: 'explorer',
+      label: 'large context',
+    });
+    manager.addContext(
+      'task-1',
+      Array.from({ length: 10 }, (_, index) => ({
+        path: `file-${index}.ts`,
+        lineCount: index === 0 ? 9 : 20 + index,
+        lastReadAt: index,
+      })),
+    );
+
+    const prompt = manager.formatForPrompt('parent-1') ?? '';
+    expect(prompt).not.toContain('file-0.ts');
+    expect(prompt).toContain('file-9.ts (29 lines)');
+    expect(prompt).toContain('(+1 more)');
+  });
+
+  test('uses configurable read context thresholds', () => {
+    const manager = new SessionManager(2, {
+      readContextMinLines: 5,
+      readContextMaxFiles: 1,
+    });
+
+    manager.remember({
+      parentSessionId: 'parent-1',
+      taskId: 'task-1',
+      agentType: 'explorer',
+      label: 'custom thresholds',
+    });
+    manager.addContext('task-1', [
+      { path: 'small.ts', lineCount: 4, lastReadAt: 1 },
+      { path: 'medium.ts', lineCount: 5, lastReadAt: 2 },
+      { path: 'large.ts', lineCount: 12, lastReadAt: 3 },
+    ]);
+
+    const prompt = manager.formatForPrompt('parent-1') ?? '';
+    expect(prompt).not.toContain('small.ts');
+    expect(prompt).toContain('large.ts (12 lines)');
+    expect(prompt).not.toContain('medium.ts');
+    expect(prompt).toContain('(+1 more)');
+  });
+
+  test('bounds stored read context files to the render cap plus overflow marker', () => {
+    const manager = new SessionManager(2, {
+      readContextMinLines: 1,
+      readContextMaxFiles: 2,
+    });
+
+    const remembered = manager.remember({
+      parentSessionId: 'parent-1',
+      taskId: 'task-1',
+      agentType: 'explorer',
+      label: 'bounded context',
+    });
+    manager.addContext(
+      'task-1',
+      Array.from({ length: 10 }, (_, index) => ({
+        path: `file-${index}.ts`,
+        lineCount: 10,
+        lastReadAt: index,
+      })),
+    );
+
+    expect(remembered.contextFiles).toHaveLength(3);
+    const prompt = manager.formatForPrompt('parent-1') ?? '';
+    expect(prompt).toContain('file-9.ts (10 lines)');
+    expect(prompt).toContain('file-8.ts (10 lines)');
+    expect(prompt).toContain('(+1 more)');
+    expect(prompt).not.toContain('file-0.ts');
+  });
+});
+
+describe('deriveTaskSessionLabel', () => {
+  test('prefers description over prompt', () => {
+    expect(
+      deriveTaskSessionLabel({
+        description: 'config schema lookup',
+        prompt: 'ignored prompt line',
+        agentType: 'explorer',
+      }),
+    ).toBe('config schema lookup');
+  });
+
+  test('falls back to prompt then generic label', () => {
+    expect(
+      deriveTaskSessionLabel({
+        prompt: '\n  inspect task resumption support  \nmore context',
+        agentType: 'explorer',
+      }),
+    ).toBe('inspect task resumption support');
+
+    expect(
+      deriveTaskSessionLabel({
+        agentType: 'fixer',
+      }),
+    ).toBe('recent fixer task');
+  });
+});

package/src/utils/session-manager.ts

@@ -0,0 +1,356 @@
+import type { AgentName } from '../config';
+
+export interface ContextFile {
+  path: string;
+  lineCount: number;
+  lineNumbers?: number[];
+  lastReadAt: number;
+}
+
+export interface RememberedTaskSession {
+  alias: string;
+  taskId: string;
+  agentType: AgentName;
+  label: string;
+  contextFiles: ContextFile[];
+  createdAt: number;
+  lastUsedAt: number;
+}
+
+type SessionGroupMap = Map<AgentName, RememberedTaskSession[]>;
+
+const MIN_CONTEXT_FILE_LINES = 10;
+const MAX_CONTEXT_FILES_PER_SESSION = 8;
+
+interface SessionManagerOptions {
+  readContextMinLines?: number;
+  readContextMaxFiles?: number;
+}
+
+function aliasPrefix(agentType: AgentName): string {
+  switch (agentType) {
+    case 'explorer':
+      return 'exp';
+    case 'librarian':
+      return 'lib';
+    case 'oracle':
+      return 'ora';
+    case 'designer':
+      return 'des';
+    case 'fixer':
+      return 'fix';
+    case 'steward':
+      return 'stw';
+    case 'interpreter':
+      return 'int';
+
+    case 'orchestrator':
+      return 'orc';
+  }
+}
+
+function normalizeWhitespace(value: string): string {
+  return value.replace(/\s+/g, ' ').trim();
+}
+
+export function deriveTaskSessionLabel(input: {
+  description?: string;
+  prompt?: string;
+  agentType: AgentName;
+}): string {
+  const preferred = normalizeWhitespace(input.description ?? '');
+  if (preferred) {
+    return preferred.slice(0, 48);
+  }
+
+  const firstPromptLine = (input.prompt ?? '')
+    .split(/\r?\n/)
+    .map((line) => normalizeWhitespace(line))
+    .find(Boolean);
+
+  if (firstPromptLine) {
+    return firstPromptLine.slice(0, 48);
+  }
+
+  return `recent ${input.agentType} task`;
+}
+
+export class SessionManager {
+  private readonly maxSessionsPerAgent: number;
+  private readonly readContextMinLines: number;
+  private readonly readContextMaxFiles: number;
+  private readonly sessionsByParent = new Map<string, SessionGroupMap>();
+  private readonly nextAliasIndexByParent = new Map<
+    string,
+    Map<AgentName, number>
+  >();
+  private orderCounter = 0;
+
+  constructor(
+    maxSessionsPerAgent: number,
+    options: SessionManagerOptions = {},
+  ) {
+    this.maxSessionsPerAgent = maxSessionsPerAgent;
+    this.readContextMinLines =
+      options.readContextMinLines ?? MIN_CONTEXT_FILE_LINES;
+    this.readContextMaxFiles =
+      options.readContextMaxFiles ?? MAX_CONTEXT_FILES_PER_SESSION;
+  }
+
+  remember(input: {
+    parentSessionId: string;
+    taskId: string;
+    agentType: AgentName;
+    label: string;
+  }): RememberedTaskSession {
+    const now = this.nextOrder();
+    const group = this.getAgentGroup(
+      input.parentSessionId,
+      input.agentType,
+      true,
+    );
+    if (!group) {
+      throw new Error('Failed to initialize session group');
+    }
+    const existing = group.find((entry) => entry.taskId === input.taskId);
+
+    if (existing) {
+      existing.label = input.label;
+      existing.lastUsedAt = this.nextOrder();
+      return existing;
+    }
+
+    const remembered: RememberedTaskSession = {
+      alias: this.nextAlias(input.parentSessionId, input.agentType),
+      taskId: input.taskId,
+      agentType: input.agentType,
+      label: input.label,
+      contextFiles: [],
+      createdAt: now,
+      lastUsedAt: now,
+    };
+
+    group.push(remembered);
+    this.trimGroup(group);
+    return remembered;
+  }
+
+  markUsed(parentSessionId: string, agentType: AgentName, key: string): void {
+    const group = this.getAgentGroup(parentSessionId, agentType, false);
+    const match = group?.find(
+      (entry) => entry.alias === key || entry.taskId === key,
+    );
+
+    if (match) {
+      match.lastUsedAt = this.nextOrder();
+    }
+  }
+
+  resolve(parentSessionId: string, agentType: AgentName, key: string) {
+    const group = this.getAgentGroup(parentSessionId, agentType, false);
+    return group?.find((entry) => entry.alias === key || entry.taskId === key);
+  }
+
+  drop(parentSessionId: string, agentType: AgentName, key: string): void {
+    const group = this.getAgentGroup(parentSessionId, agentType, false);
+    if (!group) return;
+
+    const next = group.filter(
+      (entry) => entry.alias !== key && entry.taskId !== key,
+    );
+    this.setAgentGroup(parentSessionId, agentType, next);
+  }
+
+  dropTask(taskId: string): void {
+    for (const [parentSessionId, groups] of this.sessionsByParent.entries()) {
+      for (const [agentType, group] of groups.entries()) {
+        const next = group.filter((entry) => entry.taskId !== taskId);
+        this.setAgentGroup(parentSessionId, agentType, next);
+      }
+    }
+  }
+
+  taskIds(): Set<string> {
+    const ids = new Set<string>();
+    for (const groups of this.sessionsByParent.values()) {
+      for (const group of groups.values()) {
+        for (const entry of group) {
+          ids.add(entry.taskId);
+        }
+      }
+    }
+    return ids;
+  }
+
+  addContext(taskId: string, files: ContextFile[]): void {
+    if (files.length === 0) return;
+
+    for (const groups of this.sessionsByParent.values()) {
+      for (const group of groups.values()) {
+        const match = group.find((entry) => entry.taskId === taskId);
+        if (!match) continue;
+
+        const existing = new Map(
+          match.contextFiles.map((file) => [file.path, file]),
+        );
+        for (const file of files) {
+          const previous = existing.get(file.path);
+          if (previous) {
+            previous.lineCount = Math.max(previous.lineCount, file.lineCount);
+            previous.lastReadAt = Math.max(
+              previous.lastReadAt,
+              file.lastReadAt,
+            );
+            continue;
+          }
+          match.contextFiles.push({ ...file });
+        }
+        this.trimContextFiles(match);
+      }
+    }
+  }
+
+  clearParent(parentSessionId: string): void {
+    this.sessionsByParent.delete(parentSessionId);
+    this.nextAliasIndexByParent.delete(parentSessionId);
+  }
+
+  formatForPrompt(parentSessionId: string): string | undefined {
+    const groups = this.sessionsByParent.get(parentSessionId);
+    if (!groups || groups.size === 0) return undefined;
+
+    const lines = [...groups.entries()]
+      .map(
+        ([agentType, entries]) =>
+          [
+            agentType,
+            [...entries].sort((a, b) => b.lastUsedAt - a.lastUsedAt),
+          ] as const,
+      )
+      .filter(([, entries]) => entries.length > 0)
+      .sort((a, b) => b[1][0].lastUsedAt - a[1][0].lastUsedAt)
+      .map(([agentType, entries]) =>
+        [
+          `- ${agentType}: ${entries
+            .map((entry) => `${entry.alias} ${entry.label}`)
+            .join('; ')}`,
+          ...entries
+            .map(
+              (entry) =>
+                [
+                  entry,
+                  formatContextFiles(entry.contextFiles, {
+                    minLines: this.readContextMinLines,
+                    maxFiles: this.readContextMaxFiles,
+                  }),
+                ] as const,
+            )
+            .filter(([, context]) => context.length > 0)
+            .map(
+              ([entry, context]) =>
+                `  Context read by ${entry.alias}: ${context}`,
+            ),
+        ].join('\n'),
+      );
+
+    if (lines.length === 0) return undefined;
+
+    return [
+      '### Resumable Sessions',
+      'Reuse only for clear continuation of the same thread. Otherwise start fresh.',
+      '',
+      ...lines,
+    ].join('\n');
+  }
+
+  private getAgentGroup(
+    parentSessionId: string,
+    agentType: AgentName,
+    create: boolean,
+  ): RememberedTaskSession[] | undefined {
+    let groups = this.sessionsByParent.get(parentSessionId);
+    if (!groups && create) {
+      groups = new Map();
+      this.sessionsByParent.set(parentSessionId, groups);
+    }
+
+    let group = groups?.get(agentType);
+    if (!group && create && groups) {
+      group = [];
+      groups.set(agentType, group);
+    }
+
+    return group;
+  }
+
+  private setAgentGroup(
+    parentSessionId: string,
+    agentType: AgentName,
+    entries: RememberedTaskSession[],
+  ): void {
+    const groups = this.sessionsByParent.get(parentSessionId);
+    if (!groups) return;
+
+    if (entries.length === 0) {
+      groups.delete(agentType);
+      if (groups.size === 0) {
+        this.sessionsByParent.delete(parentSessionId);
+        this.nextAliasIndexByParent.delete(parentSessionId);
+      }
+      return;
+    }
+
+    groups.set(agentType, entries);
+  }
+
+  private nextAlias(parentSessionId: string, agentType: AgentName): string {
+    let counters = this.nextAliasIndexByParent.get(parentSessionId);
+    if (!counters) {
+      counters = new Map();
+      this.nextAliasIndexByParent.set(parentSessionId, counters);
+    }
+
+    const next = (counters.get(agentType) ?? 0) + 1;
+    counters.set(agentType, next);
+    return `${aliasPrefix(agentType)}-${next}`;
+  }
+
+  private trimGroup(group: RememberedTaskSession[]): void {
+    group.sort((a, b) => b.lastUsedAt - a.lastUsedAt);
+    if (group.length > this.maxSessionsPerAgent) {
+      group.length = this.maxSessionsPerAgent;
+    }
+  }
+
+  private trimContextFiles(entry: RememberedTaskSession): void {
+    if (this.readContextMaxFiles === 0) {
+      entry.contextFiles = [];
+      return;
+    }
+
+    entry.contextFiles = entry.contextFiles
+      .filter((file) => file.lineCount >= this.readContextMinLines)
+      .sort((a, b) => b.lastReadAt - a.lastReadAt)
+      .slice(0, this.readContextMaxFiles + 1);
+  }
+
+  private nextOrder(): number {
+    this.orderCounter += 1;
+    return this.orderCounter;
+  }
+}
+
+function formatContextFiles(
+  files: ContextFile[],
+  options: { minLines: number; maxFiles: number },
+): string {
+  const eligible = files
+    .filter((file) => file.lineCount >= options.minLines)
+    .sort((a, b) => b.lastReadAt - a.lastReadAt);
+  const shown = eligible.slice(0, options.maxFiles);
+  const rest = eligible.length - shown.length;
+  const rendered = shown.map(
+    (file) => `${file.path} (${file.lineCount} lines)`,
+  );
+  return `${rendered.join(', ')}${rest > 0 ? ` (+${rest} more)` : ''}`;
+}

package/src/utils/session.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  isForwardableImagePart,
+  normalizeImagePartsForChildPrompt,
+  type PromptBodyPart,
+} from './session';
+
+describe('isForwardableImagePart', () => {
+  test('accepts legacy image part type', () => {
+    expect(isForwardableImagePart({ type: 'image' })).toBe(true);
+  });
+
+  test('accepts OpenCode file part with image/* mime', () => {
+    expect(
+      isForwardableImagePart({
+        type: 'file',
+        mime: 'image/png',
+        url: 'https://example.com/blob',
+      }),
+    ).toBe(true);
+    expect(
+      isForwardableImagePart({
+        type: 'file',
+        mime: 'IMAGE/JPEG',
+        url: 'https://example.com/blob',
+      }),
+    ).toBe(true);
+  });
+
+  test('rejects non-image file mime', () => {
+    expect(
+      isForwardableImagePart({
+        type: 'file',
+        mime: 'application/pdf',
+        url: 'x',
+      }),
+    ).toBe(false);
+  });
+
+  test('accepts file part with image-like filename when mime absent', () => {
+    expect(
+      isForwardableImagePart({
+        type: 'file',
+        url: 'x',
+        filename: 'clipboard.webp',
+      }),
+    ).toBe(true);
+  });
+
+  test('rejects plain text parts', () => {
+    expect(isForwardableImagePart({ type: 'text', text: 'hi' })).toBe(false);
+  });
+});
+
+describe('normalizeImagePartsForChildPrompt', () => {
+  test('drops stored IDs and keeps FilePartInput-shaped drafts', () => {
+    const normalized = normalizeImagePartsForChildPrompt([
+      {
+        type: 'file',
+        mime: 'image/png',
+        url: 'https://cdn.example.com/a.png',
+        id: 'part1',
+        sessionID: 'sess',
+        messageID: 'msg',
+      } as PromptBodyPart,
+    ]);
+    expect(normalized).toEqual([
+      {
+        type: 'file',
+        mime: 'image/png',
+        url: 'https://cdn.example.com/a.png',
+      },
+    ]);
+  });
+
+  test('resolves file source.path to file URL when url missing', () => {
+    const normalized = normalizeImagePartsForChildPrompt(
+      [
+        {
+          type: 'file',
+          mime: 'image/png',
+          url: '',
+          source: { type: 'file', path: 'assets/clip.png' },
+        } as PromptBodyPart,
+      ],
+      '/workspace/proj',
+    );
+    expect(normalized.length).toBe(1);
+    expect(normalized[0]?.type).toBe('file');
+    expect(normalized[0]?.mime).toBe('image/png');
+    expect(String(normalized[0]?.url)).toMatch(/^file:/);
+    expect(String(normalized[0]?.url)).toMatch(/clip\.png/);
+  });
+
+  test('maps legacy data URL image part to file draft', () => {
+    const normalized = normalizeImagePartsForChildPrompt([
+      {
+        type: 'image',
+        image: 'data:image/gif;base64,R0lGODlhAQABAAAAACw=',
+      } as PromptBodyPart,
+    ]);
+    expect(normalized).toEqual([
+      {
+        type: 'file',
+        mime: 'image/gif',
+        url: 'data:image/gif;base64,R0lGODlhAQABAAAAACw=',
+      },
+    ]);
+  });
+});