refactor: Phases 4+5 — clean SessionDiscoveryDeps and fix last direct DA calls

Phase 4: Drop 7 individual DataAccess fields from SessionDiscoveryDeps.
SessionDiscovery now only needs ecosystems + log/warn/error + optional override.
Updated constructor calls in extension.ts and cli/src/helpers.ts.

Phase 5 (partial): Fix last 3 direct this.openCode.* calls in extension.ts.
- getEditorTypeFromPath(): use findEcosystem(p)?.id === 'opencode' instead of
  this.openCode.isOpenCodeSessionFile()
- Folder counting loop: use adapter.getEditorRoot() for all adapter-owned sessions
  (was only handling OpenCode; now handles Crush and other virtual-path sessions too)

Phase 3 tests: Add 24 unit tests covering adapter discovery:
- isDiscoverable() type guard (all 7 adapters + negative case)
- handles() path recognition for OpenCode/Continue/ClaudeCode/MistralVibe
- getCandidatePaths() structure validation for all adapters
- getEditorRoot() returns non-empty string for all adapters
- discover() returns valid DiscoveryResult shape (graceful empty dirs)
- getCandidatePaths/discover consistency invariant

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: rajbos

cli/src/helpers.ts

@@ -102,7 +102,7 @@ const _ecosystems: IEcosystemAdapter[] = [
 
 /** Create session discovery instance for CLI */
 function createSessionDiscovery(): SessionDiscovery {
-	return new SessionDiscovery({ log, warn, error, ecosystems: _ecosystems, openCode: _openCodeInstance, crush: _crushInstance, continue_: _continueInstance, visualStudio: _visualStudioInstance, claudeCode: _claudeCodeInstance, claudeDesktopCowork: _claudeDesktopCoworkInstance, mistralVibe: _mistralVibeInstance });
+	return new SessionDiscovery({ log, warn, error, ecosystems: _ecosystems });
 }
 
 /** Discover all session files on this machine */

vscode-extension/src/extension.ts

@@ -308,7 +308,7 @@ class CopilotTokenTracker implements vscode.Disposable {
 	 * Returns the filename without the .agent.md extension.
 	 */
 	private getEditorTypeFromPath(filePath: string): string {
-		return _getEditorTypeFromPath(filePath, (p) => this.openCode.isOpenCodeSessionFile(p));
+		return _getEditorTypeFromPath(filePath, (p) => this.findEcosystem(p)?.id === 'opencode');
 	}
 
 	/** Returns the first adapter that claims this session file, or null for Copilot Chat sessions. */
@@ -850,13 +850,6 @@ class CopilotTokenTracker implements vscode.Disposable {
 			warn: (m) => this.warn(m),
 			error: (m, e) => this.error(m, e),
 			ecosystems: this.ecosystems,
-			openCode: this.openCode,
-			crush: this.crush,
-			visualStudio: this.visualStudio,
-			continue_: this.continue_,
-			claudeCode: this.claudeCode,
-			claudeDesktopCowork: this.claudeDesktopCowork,
-			mistralVibe: this.mistralVibe,
 			sampleDataDirectoryOverride: () => this.localRegressionSampleDataDir,
 		});
 		this.context = context;
@@ -6838,9 +6831,10 @@ ${hashtag}`;
         "session-state",
       );
       for (const file of sessionFiles) {
-        // Handle OpenCode DB virtual paths (opencode.db#ses_<id>)
-        if (this.openCode.isOpenCodeDbSession(file)) {
-          const editorRoot = this.openCode.getOpenCodeDataDir();
+        // Handle virtual/adapter-owned paths (e.g. opencode.db#ses_<id>, crush.db#<uuid>)
+        const eco = this.findEcosystem(file);
+        if (eco) {
+          const editorRoot = eco.getEditorRoot(file);
           dirCounts.set(editorRoot, (dirCounts.get(editorRoot) || 0) + 1);
           continue;
         }

vscode-extension/src/sessionDiscovery.ts

@@ -5,13 +5,6 @@ import * as vscode from 'vscode';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import type { OpenCodeDataAccess } from './opencode';
-import type { CrushDataAccess } from './crush';
-import type { ContinueDataAccess } from './continue';
-import type { VisualStudioDataAccess } from "./visualstudio";
-import type { ClaudeCodeDataAccess } from './claudecode';
-import type { ClaudeDesktopCoworkDataAccess } from './claudedesktop';
-import type { MistralVibeDataAccess } from './mistralvibe';
 import type { IEcosystemAdapter } from './ecosystemAdapter';
 import { isDiscoverable } from './ecosystemAdapter';
 
@@ -20,13 +13,6 @@ export interface SessionDiscoveryDeps {
 	warn: (message: string) => void;
 	error: (message: string, error?: any) => void;
 	ecosystems: IEcosystemAdapter[];
-	openCode: OpenCodeDataAccess;
-	crush: CrushDataAccess;
-	continue_: ContinueDataAccess;
-	visualStudio: VisualStudioDataAccess;
-	claudeCode: ClaudeCodeDataAccess;
-	claudeDesktopCowork: ClaudeDesktopCoworkDataAccess;
-	mistralVibe: MistralVibeDataAccess;
 	sampleDataDirectoryOverride?: () => string | undefined;
 }
 

vscode-extension/test/unit/ecosystemAdapters.test.ts

@@ -0,0 +1,255 @@
+/**
+ * Unit tests for ecosystem adapters and the IDiscoverableEcosystem interface.
+ * Tests cover: isDiscoverable type guard, handles(), getCandidatePaths(),
+ * getEditorRoot(), and discover() adapter loop behavior.
+ */
+import test from 'node:test';
+import * as assert from 'node:assert/strict';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+import { isDiscoverable } from '../../src/ecosystemAdapter';
+import type { IEcosystemAdapter } from '../../src/ecosystemAdapter';
+
+import { OpenCodeAdapter } from '../../src/adapters/openCodeAdapter';
+import { CrushAdapter } from '../../src/adapters/crushAdapter';
+import { ContinueAdapter } from '../../src/adapters/continueAdapter';
+import { ClaudeCodeAdapter } from '../../src/adapters/claudeCodeAdapter';
+import { ClaudeDesktopAdapter } from '../../src/adapters/claudeDesktopAdapter';
+import { VisualStudioAdapter } from '../../src/adapters/visualStudioAdapter';
+import { MistralVibeAdapter } from '../../src/adapters/mistralVibeAdapter';
+
+import { OpenCodeDataAccess } from '../../src/opencode';
+import { CrushDataAccess } from '../../src/crush';
+import { ContinueDataAccess } from '../../src/continue';
+import { ClaudeCodeDataAccess } from '../../src/claudecode';
+import { ClaudeDesktopCoworkDataAccess } from '../../src/claudedesktop';
+import { VisualStudioDataAccess } from '../../src/visualstudio';
+import { MistralVibeDataAccess } from '../../src/mistralvibe';
+
+// Stub functions for adapters requiring callbacks
+const noopEstimateTokens = (_text: string, _model?: string) => 0;
+const noopIsMcpTool = (_name: string) => false;
+const noopExtractMcpServerName = (_name: string) => '';
+
+// Adapter instances
+const openCodeDA = new OpenCodeDataAccess(null as any);
+const crushDA = new CrushDataAccess(null as any);
+const continueDA = new ContinueDataAccess();
+const claudeCodeDA = new ClaudeCodeDataAccess();
+const claudeDesktopDA = new ClaudeDesktopCoworkDataAccess();
+const visualStudioDA = new VisualStudioDataAccess();
+const mistralVibeDA = new MistralVibeDataAccess();
+
+const openCodeAdapter = new OpenCodeAdapter(openCodeDA);
+const crushAdapter = new CrushAdapter(crushDA);
+const continueAdapter = new ContinueAdapter(continueDA);
+const claudeCodeAdapter = new ClaudeCodeAdapter(claudeCodeDA);
+const claudeDesktopAdapter = new ClaudeDesktopAdapter(claudeDesktopDA, noopIsMcpTool, noopExtractMcpServerName, noopEstimateTokens);
+const visualStudioAdapter = new VisualStudioAdapter(visualStudioDA, noopEstimateTokens);
+const mistralVibeAdapter = new MistralVibeAdapter(mistralVibeDA);
+
+const allAdapters: IEcosystemAdapter[] = [
+    openCodeAdapter, crushAdapter, continueAdapter,
+    claudeCodeAdapter, claudeDesktopAdapter, visualStudioAdapter, mistralVibeAdapter,
+];
+
+// ---------------------------------------------------------------------------
+// isDiscoverable type guard
+// ---------------------------------------------------------------------------
+
+test('isDiscoverable: returns true for all 7 adapters', () => {
+    for (const adapter of allAdapters) {
+        assert.ok(isDiscoverable(adapter), `Expected ${adapter.id} to be discoverable`);
+    }
+});
+
+test('isDiscoverable: returns false for plain IEcosystemAdapter without discover()', () => {
+    const plainAdapter: IEcosystemAdapter = {
+        id: 'plain', displayName: 'Plain',
+        handles: () => false, getBackingPath: (f) => f, stat: async (f) => { throw new Error(); },
+        getTokens: async () => ({ tokens: 0, thinkingTokens: 0, actualTokens: 0 }),
+        countInteractions: async () => 0, getModelUsage: async () => ({}),
+        getMeta: async () => ({ title: undefined, firstInteraction: null, lastInteraction: null }),
+        getEditorRoot: () => '',
+    };
+    assert.ok(!isDiscoverable(plainAdapter));
+});
+
+// ---------------------------------------------------------------------------
+// Adapter IDs and display names
+// ---------------------------------------------------------------------------
+
+test('adapter IDs are stable lowercase identifiers', () => {
+    assert.equal(openCodeAdapter.id, 'opencode');
+    assert.equal(crushAdapter.id, 'crush');
+    assert.equal(continueAdapter.id, 'continue');
+    assert.equal(claudeCodeAdapter.id, 'claudecode');
+    assert.equal(claudeDesktopAdapter.id, 'claudedesktop');
+    assert.equal(visualStudioAdapter.id, 'visualstudio');
+    assert.equal(mistralVibeAdapter.id, 'mistralvibe');
+});
+
+// ---------------------------------------------------------------------------
+// handles() — path recognition
+// ---------------------------------------------------------------------------
+
+test('OpenCodeAdapter.handles: recognises JSON session paths', () => {
+    const p = path.join(openCodeDA.getOpenCodeDataDir(), 'storage', 'session', 'ses_abc123.json');
+    assert.ok(openCodeAdapter.handles(p));
+});
+
+test('OpenCodeAdapter.handles: recognises DB virtual paths', () => {
+    const p = path.join(openCodeDA.getOpenCodeDataDir(), 'opencode.db#ses_abc123');
+    assert.ok(openCodeAdapter.handles(p));
+});
+
+test('OpenCodeAdapter.handles: rejects unrelated paths', () => {
+    assert.ok(!openCodeAdapter.handles(path.join(os.homedir(), '.continue', 'sessions', 'abc.json')));
+    assert.ok(!openCodeAdapter.handles(path.join(os.homedir(), '.claude', 'projects', 'hash', 'abc.jsonl')));
+});
+
+test('ContinueAdapter.handles: recognises ~/.continue/sessions paths', () => {
+    const p = path.join(os.homedir(), '.continue', 'sessions', 'abc123.json');
+    assert.ok(continueAdapter.handles(p));
+});
+
+test('ContinueAdapter.handles: rejects unrelated paths', () => {
+    assert.ok(!continueAdapter.handles(path.join(os.homedir(), '.claude', 'projects', 'hash', 'abc.jsonl')));
+});
+
+test('ClaudeCodeAdapter.handles: recognises ~/.claude/projects paths', () => {
+    const p = path.join(os.homedir(), '.claude', 'projects', 'my-project', 'abc123.jsonl');
+    assert.ok(claudeCodeAdapter.handles(p));
+});
+
+test('ClaudeCodeAdapter.handles: rejects ~/.claude/stats-cache.json', () => {
+    assert.ok(!claudeCodeAdapter.handles(path.join(os.homedir(), '.claude', 'stats-cache.json')));
+});
+
+test('MistralVibeAdapter.handles: recognises ~/.vibe/logs/session paths', () => {
+    const p = path.join(os.homedir(), '.vibe', 'logs', 'session', 'session_20240101_120000_abc12345', 'meta.json');
+    assert.ok(mistralVibeAdapter.handles(p));
+});
+
+test('MistralVibeAdapter.handles: rejects unrelated paths', () => {
+    assert.ok(!mistralVibeAdapter.handles(path.join(os.homedir(), '.claude', 'projects', 'hash', 'abc.jsonl')));
+});
+
+// ---------------------------------------------------------------------------
+// getCandidatePaths() — structure validation
+// ---------------------------------------------------------------------------
+
+test('getCandidatePaths: all adapters return array of {path, source}', () => {
+    for (const adapter of allAdapters) {
+        if (!isDiscoverable(adapter)) { continue; }
+        const paths = adapter.getCandidatePaths();
+        assert.ok(Array.isArray(paths), `${adapter.id}: expected array`);
+        for (const cp of paths) {
+            assert.ok(typeof cp.path === 'string' && cp.path.length > 0, `${adapter.id}: path should be non-empty string`);
+            assert.ok(typeof cp.source === 'string' && cp.source.length > 0, `${adapter.id}: source should be non-empty string`);
+        }
+    }
+});
+
+test('OpenCodeAdapter.getCandidatePaths: returns both JSON dir and DB paths', () => {
+    const paths = openCodeAdapter.getCandidatePaths();
+    const sources = paths.map(p => p.source);
+    assert.ok(sources.some(s => s.includes('JSON')), 'Should include JSON path');
+    assert.ok(sources.some(s => s.includes('DB')), 'Should include DB path');
+    assert.equal(paths.length, 2);
+});
+
+test('CrushAdapter.getCandidatePaths: always includes projects.json path', () => {
+    const paths = crushAdapter.getCandidatePaths();
+    assert.ok(paths.length >= 1);
+    assert.ok(paths[0].path.endsWith('projects.json'));
+    assert.ok(paths[0].source.includes('Crush'));
+});
+
+test('ContinueAdapter.getCandidatePaths: returns sessions directory path', () => {
+    const paths = continueAdapter.getCandidatePaths();
+    assert.equal(paths.length, 1);
+    assert.ok(paths[0].path.length > 0);
+    assert.equal(paths[0].source, 'Continue');
+});
+
+test('ClaudeCodeAdapter.getCandidatePaths: returns Claude Code projects directory', () => {
+    const paths = claudeCodeAdapter.getCandidatePaths();
+    assert.equal(paths.length, 1);
+    assert.ok(paths[0].path.includes('.claude'));
+    assert.equal(paths[0].source, 'Claude Code');
+});
+
+test('MistralVibeAdapter.getCandidatePaths: returns session log directory', () => {
+    const paths = mistralVibeAdapter.getCandidatePaths();
+    assert.equal(paths.length, 1);
+    assert.ok(paths[0].path.includes('.vibe'));
+    assert.equal(paths[0].source, 'Mistral Vibe');
+});
+
+// ---------------------------------------------------------------------------
+// getEditorRoot() — returns non-empty string
+// ---------------------------------------------------------------------------
+
+test('getEditorRoot: all adapters return non-empty string', () => {
+    const dummyFile = '/dummy/path/session.json';
+    for (const adapter of allAdapters) {
+        const root = adapter.getEditorRoot(dummyFile);
+        assert.ok(typeof root === 'string' && root.length > 0, `${adapter.id}: getEditorRoot should return non-empty string`);
+    }
+});
+
+test('OpenCodeAdapter.getEditorRoot: returns opencode data directory', () => {
+    const root = openCodeAdapter.getEditorRoot('/any/path');
+    assert.ok(root.includes('opencode'));
+});
+
+test('ContinueAdapter.getEditorRoot: returns continue data directory', () => {
+    const root = continueAdapter.getEditorRoot('/any/path');
+    assert.ok(root.includes('.continue'));
+});
+
+test('ClaudeCodeAdapter.getEditorRoot: returns claude data directory', () => {
+    const root = claudeCodeAdapter.getEditorRoot('/any/path');
+    assert.ok(root.includes('.claude'));
+});
+
+// ---------------------------------------------------------------------------
+// discover() — adapter loop behavior (empty directories)
+// ---------------------------------------------------------------------------
+
+test('discover: returns DiscoveryResult shape when no sessions exist', async () => {
+    // All adapters should gracefully return empty sessionFiles when data dirs don't exist
+    for (const adapter of allAdapters) {
+        if (!isDiscoverable(adapter)) { continue; }
+        const result = await adapter.discover(() => { /* noop */ });
+        assert.ok(typeof result === 'object', `${adapter.id}: should return object`);
+        assert.ok(Array.isArray(result.sessionFiles), `${adapter.id}: sessionFiles should be array`);
+        assert.ok(Array.isArray(result.candidatePaths), `${adapter.id}: candidatePaths should be array`);
+        // candidatePaths from discover() should match getCandidatePaths() (or be a superset for crush multi-project)
+        const syncPaths = adapter.getCandidatePaths();
+        for (const cp of syncPaths) {
+            const found = result.candidatePaths.some(rp => rp.path === cp.path && rp.source === cp.source);
+            assert.ok(found, `${adapter.id}: discover() candidatePaths should include getCandidatePaths() entry: ${cp.path}`);
+        }
+    }
+});
+
+// ---------------------------------------------------------------------------
+// getCandidatePaths() / discover() consistency
+// ---------------------------------------------------------------------------
+
+test('getCandidatePaths paths are consistent with discover candidatePaths', async () => {
+    // For all adapters, getCandidatePaths() should be a subset of discover().candidatePaths
+    // (Crush can return MORE paths from discover if projects are found)
+    for (const adapter of allAdapters) {
+        if (!isDiscoverable(adapter)) { continue; }
+        const syncPaths = adapter.getCandidatePaths().map(cp => cp.path);
+        const discoverResult = await adapter.discover(() => { /* noop */ });
+        const discoverPaths = discoverResult.candidatePaths.map(cp => cp.path);
+        for (const sp of syncPaths) {
+            assert.ok(discoverPaths.includes(sp), `${adapter.id}: sync path '${sp}' missing from discover() result`);
+        }
+    }
+});