forkit-connect 0.1.5 → 0.1.6

package/dist/v1/runtime-editor-activity.js

@@ -0,0 +1,821 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseClaudeSessionJsonl = parseClaudeSessionJsonl;
+exports.parseEditorActivityThreadsBlob = parseEditorActivityThreadsBlob;
+exports.parseCopilotChatSessionIndexBlob = parseCopilotChatSessionIndexBlob;
+exports.parseCopilotSelectedModelLabels = parseCopilotSelectedModelLabels;
+exports.parseEditorOpenFileStateBlob = parseEditorOpenFileStateBlob;
+exports.collectCodexEditorThreads = collectCodexEditorThreads;
+exports.collectCopilotEditorActivity = collectCopilotEditorActivity;
+exports.collectClaudeProjectActivity = collectClaudeProjectActivity;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const MAX_ACTIVITY_THREADS = 4;
+const MAX_ACTIVITY_THREAD_LABEL_LENGTH = 96;
+const MAX_ACTIVITY_MODEL_LABEL_LENGTH = 64;
+const VSCODE_AGENT_SESSIONS_STATE_KEY = 'agentSessions.model.cache';
+const COPILOT_EXTENSION_STATE_KEY = 'GitHub.copilot-chat';
+const COPILOT_CHAT_SESSION_INDEX_KEY = 'chat.ChatSessionStore.index';
+const COPILOT_ACTIVE_SESSION_STATE_KEY = 'memento/interactive-session-view-copilot';
+const EDITOR_OPEN_FILE_STATE_KEY = 'memento/workbench.editors.files.textFileEditor';
+const MAX_ACTIVITY_SCOPE_FILES = 6;
+function trimOptional(value) {
+    const normalized = String(value ?? '').trim();
+    return normalized.length ? normalized : null;
+}
+function normalizeActivityLabel(value, maxLength = MAX_ACTIVITY_THREAD_LABEL_LENGTH) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.replace(/\s+/g, ' ').trim();
+    if (!normalized)
+        return null;
+    if (normalized.length <= maxLength)
+        return normalized;
+    return `${normalized.slice(0, Math.max(1, maxLength - 1)).trimEnd()}…`;
+}
+function realpathSafe(value) {
+    const resolved = node_path_1.default.resolve(value);
+    try {
+        const nativeRealpath = node_fs_1.default.realpathSync.native;
+        return typeof nativeRealpath === 'function' ? nativeRealpath(resolved) : node_fs_1.default.realpathSync(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+function normalizeIsoTimestamp(value) {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+        return new Date(value).toISOString();
+    }
+    if (typeof value === 'string') {
+        const numeric = Number(value);
+        if (Number.isFinite(numeric) && numeric > 0) {
+            return new Date(numeric).toISOString();
+        }
+        const parsed = Date.parse(value);
+        if (Number.isFinite(parsed)) {
+            return new Date(parsed).toISOString();
+        }
+    }
+    return null;
+}
+function decodeWorkspaceFolderLocation(value) {
+    const normalized = trimOptional(value);
+    if (!normalized)
+        return null;
+    if (normalized.startsWith('file://')) {
+        try {
+            return realpathSafe(decodeURIComponent(new URL(normalized).pathname));
+        }
+        catch {
+            return null;
+        }
+    }
+    return realpathSafe(normalized);
+}
+function readWorkspaceStorageConfigPaths(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return [];
+    const record = value;
+    const resolved = [
+        typeof record.folder === 'string' ? decodeWorkspaceFolderLocation(record.folder) : null,
+        typeof record.configuration === 'string' ? decodeWorkspaceFolderLocation(record.configuration) : null,
+    ];
+    if (record.workspace && typeof record.workspace === 'object' && !Array.isArray(record.workspace)) {
+        const nested = record.workspace;
+        resolved.push(typeof nested.folder === 'string' ? decodeWorkspaceFolderLocation(nested.folder) : null, typeof nested.configuration === 'string' ? decodeWorkspaceFolderLocation(nested.configuration) : null);
+    }
+    return resolved.filter((item) => Boolean(item));
+}
+function candidateWorkspaceStorageDirs(host) {
+    const home = node_os_1.default.homedir();
+    const appData = process.env.APPDATA || node_path_1.default.join(home, 'AppData', 'Roaming');
+    if (process.platform === 'darwin') {
+        return [
+            host === 'vscode'
+                ? node_path_1.default.join(home, 'Library', 'Application Support', 'Code', 'User', 'workspaceStorage')
+                : node_path_1.default.join(home, 'Library', 'Application Support', 'Cursor', 'User', 'workspaceStorage'),
+        ];
+    }
+    if (process.platform === 'win32') {
+        return [
+            host === 'vscode'
+                ? node_path_1.default.join(appData, 'Code', 'User', 'workspaceStorage')
+                : node_path_1.default.join(appData, 'Cursor', 'User', 'workspaceStorage'),
+        ];
+    }
+    return [
+        host === 'vscode'
+            ? node_path_1.default.join(home, '.config', 'Code', 'User', 'workspaceStorage')
+            : node_path_1.default.join(home, '.config', 'Cursor', 'User', 'workspaceStorage'),
+    ];
+}
+const EDITOR_WORKSPACE_THREAD_SOURCES = [
+    {
+        host: 'vscode',
+        stateCacheKey: VSCODE_AGENT_SESSIONS_STATE_KEY,
+        workspaceStorageDirs: candidateWorkspaceStorageDirs('vscode'),
+    },
+    {
+        host: 'cursor',
+        stateCacheKey: VSCODE_AGENT_SESSIONS_STATE_KEY,
+        workspaceStorageDirs: candidateWorkspaceStorageDirs('cursor'),
+    },
+];
+function findEditorWorkspaceStorageDir(workspaceStorageDirs, repoRoot) {
+    const normalizedRepoRoot = realpathSafe(repoRoot);
+    for (const workspaceStorageDir of workspaceStorageDirs) {
+        let directoryEntries = [];
+        try {
+            directoryEntries = node_fs_1.default.readdirSync(workspaceStorageDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of directoryEntries) {
+            if (!entry.isDirectory())
+                continue;
+            const candidateDir = node_path_1.default.join(workspaceStorageDir, entry.name);
+            const workspaceJsonPath = node_path_1.default.join(candidateDir, 'workspace.json');
+            let parsedWorkspaceConfig;
+            try {
+                parsedWorkspaceConfig = JSON.parse(node_fs_1.default.readFileSync(workspaceJsonPath, 'utf8'));
+            }
+            catch {
+                continue;
+            }
+            const workspacePaths = readWorkspaceStorageConfigPaths(parsedWorkspaceConfig);
+            if (workspacePaths.some((candidate) => candidate === normalizedRepoRoot)) {
+                return candidateDir;
+            }
+        }
+    }
+    return null;
+}
+function readSqliteItemValue(dbPath, key) {
+    if (!node_fs_1.default.existsSync(dbPath))
+        return null;
+    const escapedKey = key.replace(/'/g, "''");
+    try {
+        const result = (0, node_child_process_1.spawnSync)('sqlite3', ['-readonly', dbPath, `select value from ItemTable where key='${escapedKey}' limit 1;`], {
+            encoding: 'utf8',
+            timeout: 2500,
+            maxBuffer: 512 * 1024,
+        });
+        if (result.status !== 0)
+            return null;
+        return trimOptional(result.stdout);
+    }
+    catch {
+        return null;
+    }
+}
+function extractThreadIdFromResource(value) {
+    const resource = trimOptional(typeof value === 'string' ? value : null);
+    if (!resource)
+        return null;
+    const trailing = resource.split('/').pop();
+    return trimOptional(trailing) ?? resource;
+}
+function normalizeActivityModelLabel(value) {
+    const normalized = normalizeActivityLabel(value, MAX_ACTIVITY_MODEL_LABEL_LENGTH);
+    if (!normalized)
+        return null;
+    if (/^<[^>]+>$/.test(normalized))
+        return null;
+    return normalized;
+}
+function normalizeRepoRelativeFilePath(repoRoot, filePath) {
+    const normalizedRoot = realpathSafe(repoRoot);
+    const normalizedFilePath = node_path_1.default.resolve(filePath);
+    const relative = node_path_1.default.relative(normalizedRoot, normalizedFilePath).replace(/\\/g, '/');
+    if (!relative || relative.startsWith('..'))
+        return null;
+    return normalizeActivityLabel(relative, 160);
+}
+function decodeFileUri(value) {
+    try {
+        const url = new URL(value);
+        if (url.protocol !== 'file:')
+            return null;
+        return realpathSafe(decodeURIComponent(url.pathname));
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeClaudeProjectDirName(repoRoot) {
+    return repoRoot
+        .replace(/\\/g, '/')
+        .replace(/[^a-zA-Z0-9._/-]+/g, '-')
+        .replace(/\//g, '-');
+}
+function extractClaudePromptTitle(value) {
+    if (typeof value === 'string') {
+        const normalized = value.replace(/\\n/g, '\n');
+        const lines = normalized.split('\n').map((line) => line.trim()).filter(Boolean);
+        for (let index = 0; index < lines.length - 1; index += 1) {
+            const marker = lines[index]?.toLowerCase().replace(/[:#*-]+/g, '').trim();
+            if (marker === 'goal' || marker === 'title' || marker === 'project') {
+                const candidate = normalizeActivityLabel(lines[index + 1]);
+                if (candidate)
+                    return candidate;
+            }
+        }
+        return normalizeActivityLabel(lines[0] || normalized);
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            if (!item || typeof item !== 'object' || Array.isArray(item))
+                continue;
+            const record = item;
+            if (record.type === 'tool_result' || record.tool_use_id)
+                continue;
+            const nested = typeof record.text === 'string'
+                ? record.text
+                : typeof record.content === 'string'
+                    ? record.content
+                    : null;
+            const normalized = extractClaudePromptTitle(nested);
+            if (normalized)
+                return normalized;
+        }
+    }
+    return null;
+}
+const MAX_ACTIVITY_FILE_LABELS = 16;
+function trimTrailingPathPunctuation(value) {
+    return value.replace(/[)\]}",'`;:.!?]+$/g, '');
+}
+function repoRootCandidates(repoRoot) {
+    const candidates = [
+        node_path_1.default.resolve(repoRoot),
+        realpathSafe(repoRoot),
+    ].map((value) => value.replace(/\\/g, '/'));
+    return [...new Set(candidates)];
+}
+function isRepoRelativeFilePath(repoRoot, candidate) {
+    const normalizedCandidate = node_path_1.default.resolve(candidate);
+    let relative = null;
+    for (const rootCandidate of repoRootCandidates(repoRoot)) {
+        const nextRelative = node_path_1.default.relative(rootCandidate, normalizedCandidate).replace(/\\/g, '/');
+        if (!nextRelative || nextRelative.startsWith('..'))
+            continue;
+        relative = nextRelative;
+        break;
+    }
+    if (!relative)
+        return null;
+    try {
+        const stats = node_fs_1.default.statSync(normalizedCandidate);
+        if (!stats.isFile())
+            return null;
+    }
+    catch {
+        return null;
+    }
+    return normalizeActivityLabel(relative, 160);
+}
+function extractRepoScopedPathsFromString(value, repoRoot) {
+    const normalizedValue = value.replace(/\\/g, '/');
+    const results = [];
+    const delimiters = new Set([' ', '\n', '\r', '\t', '"', '\'', '`', '<', '>', '|', '&', ';', '(', ')', '[', ']', '{', '}', ',']);
+    for (const rootCandidate of repoRootCandidates(repoRoot)) {
+        if (!normalizedValue.includes(rootCandidate))
+            continue;
+        let cursor = 0;
+        while (cursor < normalizedValue.length) {
+            const start = normalizedValue.indexOf(rootCandidate, cursor);
+            if (start === -1)
+                break;
+            let end = start + rootCandidate.length;
+            while (end < normalizedValue.length && !delimiters.has(normalizedValue[end] ?? '')) {
+                end += 1;
+            }
+            results.push(trimTrailingPathPunctuation(normalizedValue.slice(start, end)));
+            cursor = end;
+        }
+    }
+    return results;
+}
+function extractClaudeFileLabelsFromValue(value, repoRoot) {
+    const queue = [value];
+    const visited = new Set();
+    const labels = [];
+    const seen = new Set();
+    let inspected = 0;
+    while (queue.length > 0 && inspected < 200) {
+        const next = queue.shift();
+        inspected += 1;
+        if (next === null || next === undefined || visited.has(next))
+            continue;
+        if (typeof next === 'string') {
+            for (const candidate of extractRepoScopedPathsFromString(next, repoRoot)) {
+                const relative = isRepoRelativeFilePath(repoRoot, candidate);
+                if (!relative)
+                    continue;
+                const key = relative.toLowerCase();
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                labels.push(relative);
+                if (labels.length >= MAX_ACTIVITY_FILE_LABELS) {
+                    return labels;
+                }
+            }
+            continue;
+        }
+        if (typeof next !== 'object')
+            continue;
+        visited.add(next);
+        if (Array.isArray(next)) {
+            queue.push(...next);
+            continue;
+        }
+        queue.push(...Object.values(next));
+    }
+    return labels;
+}
+function parseClaudeSessionJsonl(raw, options) {
+    if (!raw) {
+        return { thread: null, modelLabels: [], fileLabels: [] };
+    }
+    let createdAt = null;
+    let lastActiveAt = null;
+    let threadLabel = null;
+    let sessionId = null;
+    const modelLabels = [];
+    const seenModels = new Set();
+    const fileLabels = [];
+    const seenFiles = new Set();
+    try {
+        for (const line of raw.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+                continue;
+            const record = parsed;
+            const timestamp = normalizeIsoTimestamp(record.timestamp);
+            if (timestamp) {
+                if (!createdAt || Date.parse(timestamp) < Date.parse(createdAt))
+                    createdAt = timestamp;
+                if (!lastActiveAt || Date.parse(timestamp) > Date.parse(lastActiveAt))
+                    lastActiveAt = timestamp;
+            }
+            sessionId = trimOptional(typeof record.sessionId === 'string' ? record.sessionId : sessionId);
+            if (record.type === 'user' && !threadLabel) {
+                const message = record.message && typeof record.message === 'object' && !Array.isArray(record.message)
+                    ? record.message
+                    : {};
+                const title = extractClaudePromptTitle(message.content);
+                if (title) {
+                    threadLabel = title;
+                }
+            }
+            if (record.type === 'assistant') {
+                const message = record.message && typeof record.message === 'object' && !Array.isArray(record.message)
+                    ? record.message
+                    : {};
+                const model = normalizeActivityModelLabel(message.model);
+                if (model) {
+                    const key = model.toLowerCase();
+                    if (!seenModels.has(key)) {
+                        seenModels.add(key);
+                        modelLabels.push(model);
+                    }
+                }
+                if (options.repoRoot && Array.isArray(message.content)) {
+                    for (const label of extractClaudeFileLabelsFromValue(message.content, options.repoRoot)) {
+                        const key = label.toLowerCase();
+                        if (seenFiles.has(key))
+                            continue;
+                        seenFiles.add(key);
+                        fileLabels.push(label);
+                        if (fileLabels.length >= MAX_ACTIVITY_FILE_LABELS)
+                            break;
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        return { thread: null, modelLabels: [], fileLabels: [] };
+    }
+    const folderScope = normalizeActivityLabel(options.folderScope, 96);
+    return {
+        thread: threadLabel
+            ? {
+                provider: 'Claude',
+                actorLabel: 'Claude',
+                threadLabel,
+                ...(sessionId ? { threadId: sessionId } : {}),
+                ...(createdAt ? { createdAt } : {}),
+                ...(lastActiveAt ? { lastActiveAt } : {}),
+                ...(folderScope ? { folderScope } : {}),
+                workspaceHost: 'claude',
+            }
+            : null,
+        modelLabels,
+        fileLabels,
+    };
+}
+function summarizeClaudeSessionFile(sessionPath, folderScope, repoRoot) {
+    try {
+        return parseClaudeSessionJsonl(node_fs_1.default.readFileSync(sessionPath, 'utf8'), { folderScope, repoRoot });
+    }
+    catch {
+        return { thread: null, modelLabels: [], fileLabels: [] };
+    }
+}
+function parseEditorActivityThreadsBlob(raw, options) {
+    if (!raw)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    const allowedProviderTypes = options.providerTypes ?? null;
+    const summaries = parsed
+        .filter((item) => Boolean(item) && typeof item === 'object' && !Array.isArray(item))
+        .reduce((accumulator, item) => {
+        const providerType = trimOptional(typeof item.providerType === 'string' ? item.providerType : null);
+        if (allowedProviderTypes && (!providerType || !allowedProviderTypes.has(providerType))) {
+            return accumulator;
+        }
+        const threadLabel = normalizeActivityLabel(item.label);
+        if (!threadLabel || threadLabel.toLowerCase() === 'new task' || threadLabel.toLowerCase() === 'new chat') {
+            return accumulator;
+        }
+        const provider = normalizeActivityLabel(item.providerLabel, 40)
+            ?? normalizeActivityLabel(options.providerLabel, 40)
+            ?? normalizeActivityLabel(providerType, 40)
+            ?? options.actorLabel;
+        const timing = item.timing && typeof item.timing === 'object' && !Array.isArray(item.timing)
+            ? item.timing
+            : {};
+        const threadId = extractThreadIdFromResource(item.resource);
+        const createdAt = normalizeIsoTimestamp(timing.created);
+        const lastActiveAt = normalizeIsoTimestamp(timing.lastRequestStarted ?? timing.lastResponseEnded ?? timing.created);
+        const folderScope = normalizeActivityLabel(options.folderScope, 96);
+        accumulator.push({
+            provider,
+            actorLabel: options.actorLabel,
+            threadLabel,
+            ...(threadId ? { threadId } : {}),
+            ...(createdAt ? { createdAt } : {}),
+            ...(lastActiveAt ? { lastActiveAt } : {}),
+            ...(folderScope ? { folderScope } : {}),
+            workspaceHost: options.workspaceHost,
+        });
+        return accumulator;
+    }, [])
+        .sort((left, right) => {
+        const rightTime = Date.parse(right.lastActiveAt || right.createdAt || '');
+        const leftTime = Date.parse(left.lastActiveAt || left.createdAt || '');
+        if (Number.isFinite(rightTime) && Number.isFinite(leftTime) && rightTime !== leftTime) {
+            return rightTime - leftTime;
+        }
+        return left.threadLabel.localeCompare(right.threadLabel);
+    });
+    const deduped = [];
+    const seen = new Set();
+    for (const item of summaries) {
+        const key = `${item.provider}|${item.threadId || item.threadLabel}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(item);
+        if (deduped.length >= MAX_ACTIVITY_THREADS)
+            break;
+    }
+    return deduped;
+}
+function parseCopilotChatSessionIndexBlob(raw, options) {
+    if (!raw)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return [];
+    const entries = parsed.entries;
+    if (!entries || typeof entries !== 'object' || Array.isArray(entries))
+        return [];
+    const summaries = Object.entries(entries)
+        .map(([entryId, value]) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return null;
+        const record = value;
+        const threadLabel = normalizeActivityLabel(record.title);
+        if (!threadLabel || threadLabel.toLowerCase() === 'new chat' || record.isEmpty === true) {
+            return null;
+        }
+        const timing = record.timing && typeof record.timing === 'object' && !Array.isArray(record.timing)
+            ? record.timing
+            : {};
+        const createdAt = normalizeIsoTimestamp(timing.created);
+        const lastActiveAt = normalizeIsoTimestamp(record.lastMessageDate ?? timing.lastRequestEnded ?? timing.lastResponseEnded ?? timing.created);
+        const threadId = trimOptional(typeof record.sessionId === 'string' ? record.sessionId : entryId);
+        const folderScope = normalizeActivityLabel(options.folderScope, 96);
+        return {
+            provider: 'GitHub Copilot Chat',
+            actorLabel: 'Copilot',
+            threadLabel,
+            ...(threadId ? { threadId } : {}),
+            ...(createdAt ? { createdAt } : {}),
+            ...(lastActiveAt ? { lastActiveAt } : {}),
+            ...(folderScope ? { folderScope } : {}),
+            workspaceHost: options.workspaceHost,
+        };
+    })
+        .filter((item) => Boolean(item))
+        .sort((left, right) => {
+        const rightTime = Date.parse(right.lastActiveAt || right.createdAt || '');
+        const leftTime = Date.parse(left.lastActiveAt || left.createdAt || '');
+        if (Number.isFinite(rightTime) && Number.isFinite(leftTime) && rightTime !== leftTime) {
+            return rightTime - leftTime;
+        }
+        return left.threadLabel.localeCompare(right.threadLabel);
+    });
+    const deduped = [];
+    const seen = new Set();
+    for (const item of summaries) {
+        const key = `${item.provider}|${item.threadId || item.threadLabel}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(item);
+        if (deduped.length >= MAX_ACTIVITY_THREADS)
+            break;
+    }
+    return deduped;
+}
+function parseCopilotSelectedModelLabels(raw) {
+    if (!raw)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return [];
+    const root = parsed;
+    const selectedModel = root.selectedModel;
+    if (!selectedModel || typeof selectedModel !== 'object' || Array.isArray(selectedModel))
+        return [];
+    const selectedRecord = selectedModel;
+    const metadata = selectedRecord.metadata && typeof selectedRecord.metadata === 'object' && !Array.isArray(selectedRecord.metadata)
+        ? selectedRecord.metadata
+        : {};
+    const extension = metadata.extension && typeof metadata.extension === 'object' && !Array.isArray(metadata.extension)
+        ? metadata.extension
+        : {};
+    const extensionValue = normalizeActivityLabel(extension.value, 64);
+    if (extensionValue && extensionValue.toLowerCase() !== 'github.copilot-chat') {
+        return [];
+    }
+    const candidates = [
+        normalizeActivityModelLabel(metadata.version),
+        normalizeActivityModelLabel(metadata.id),
+        normalizeActivityModelLabel(selectedRecord.identifier),
+        normalizeActivityModelLabel(metadata.name),
+    ].filter((item) => Boolean(item));
+    const result = [];
+    const seen = new Set();
+    for (const candidate of candidates) {
+        const key = candidate.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(candidate);
+    }
+    return result;
+}
+function parseEditorOpenFileStateBlob(raw, options) {
+    if (!raw)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return [];
+    const textEditorViewState = parsed.textEditorViewState;
+    if (!Array.isArray(textEditorViewState))
+        return [];
+    const results = [];
+    const seen = new Set();
+    for (const entry of textEditorViewState) {
+        if (!Array.isArray(entry) || typeof entry[0] !== 'string')
+            continue;
+        const decodedPath = decodeFileUri(entry[0]);
+        if (!decodedPath)
+            continue;
+        const relative = normalizeRepoRelativeFilePath(options.repoRoot, decodedPath);
+        if (!relative)
+            continue;
+        const key = relative.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        results.push(relative);
+        if (results.length >= MAX_ACTIVITY_SCOPE_FILES)
+            break;
+    }
+    return results;
+}
+function collectCodexEditorThreads(repo) {
+    if (!repo.isGitRepo || !repo.rootPath)
+        return [];
+    const folderScope = normalizeActivityLabel(repo.relativeCwd || '.', 96) || '.';
+    const threadEntries = [];
+    const seen = new Set();
+    for (const source of EDITOR_WORKSPACE_THREAD_SOURCES) {
+        const workspaceDir = findEditorWorkspaceStorageDir(source.workspaceStorageDirs, repo.rootPath);
+        if (!workspaceDir)
+            continue;
+        const rawState = readSqliteItemValue(node_path_1.default.join(workspaceDir, 'state.vscdb'), source.stateCacheKey);
+        const nextEntries = parseEditorActivityThreadsBlob(rawState, {
+            actorLabel: 'Codex',
+            providerTypes: new Set(['openai-codex']),
+            providerLabel: 'Codex',
+            folderScope,
+            workspaceHost: source.host,
+        });
+        for (const entry of nextEntries) {
+            const key = `${entry.provider}|${entry.threadId || entry.threadLabel}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            threadEntries.push(entry);
+            if (threadEntries.length >= MAX_ACTIVITY_THREADS) {
+                return threadEntries;
+            }
+        }
+    }
+    return threadEntries;
+}
+function collectCopilotEditorActivity(repo) {
+    if (!repo.isGitRepo || !repo.rootPath) {
+        return {
+            threads: [],
+            modelLabels: [],
+            fileLabels: [],
+            scopeFileLabels: [],
+        };
+    }
+    const folderScope = normalizeActivityLabel(repo.relativeCwd || '.', 96) || '.';
+    const threadEntries = [];
+    const modelLabels = [];
+    const scopeFileLabels = [];
+    const seenThreads = new Set();
+    const seenModels = new Set();
+    const seenScopeFiles = new Set();
+    for (const source of EDITOR_WORKSPACE_THREAD_SOURCES) {
+        const workspaceDir = findEditorWorkspaceStorageDir(source.workspaceStorageDirs, repo.rootPath);
+        if (!workspaceDir)
+            continue;
+        const dbPath = node_path_1.default.join(workspaceDir, 'state.vscdb');
+        const copilotExtensionState = readSqliteItemValue(dbPath, COPILOT_EXTENSION_STATE_KEY);
+        if (!copilotExtensionState)
+            continue;
+        const nextThreads = parseCopilotChatSessionIndexBlob(readSqliteItemValue(dbPath, COPILOT_CHAT_SESSION_INDEX_KEY), {
+            folderScope,
+            workspaceHost: source.host,
+        });
+        for (const entry of nextThreads) {
+            const key = `${entry.provider}|${entry.threadId || entry.threadLabel}`;
+            if (seenThreads.has(key))
+                continue;
+            seenThreads.add(key);
+            threadEntries.push(entry);
+            if (threadEntries.length >= MAX_ACTIVITY_THREADS)
+                break;
+        }
+        for (const label of parseCopilotSelectedModelLabels(readSqliteItemValue(dbPath, COPILOT_ACTIVE_SESSION_STATE_KEY))) {
+            const key = label.toLowerCase();
+            if (seenModels.has(key))
+                continue;
+            seenModels.add(key);
+            modelLabels.push(label);
+        }
+        for (const label of parseEditorOpenFileStateBlob(readSqliteItemValue(dbPath, EDITOR_OPEN_FILE_STATE_KEY), { repoRoot: repo.rootPath })) {
+            const key = label.toLowerCase();
+            if (seenScopeFiles.has(key))
+                continue;
+            seenScopeFiles.add(key);
+            scopeFileLabels.push(label);
+            if (scopeFileLabels.length >= MAX_ACTIVITY_SCOPE_FILES)
+                break;
+        }
+        if (threadEntries.length >= MAX_ACTIVITY_THREADS)
+            break;
+    }
+    return {
+        threads: threadEntries,
+        modelLabels,
+        fileLabels: [],
+        scopeFileLabels,
+    };
+}
+function collectClaudeProjectActivity(repo) {
+    if (!repo.isGitRepo || !repo.rootPath) {
+        return {
+            threads: [],
+            modelLabels: [],
+            fileLabels: [],
+            scopeFileLabels: [],
+        };
+    }
+    const folderScope = normalizeActivityLabel(repo.relativeCwd || '.', 96) || '.';
+    const projectDir = node_path_1.default.join(node_os_1.default.homedir(), '.claude', 'projects', normalizeClaudeProjectDirName(repo.rootPath));
+    if (!node_fs_1.default.existsSync(projectDir)) {
+        return {
+            threads: [],
+            modelLabels: [],
+            fileLabels: [],
+            scopeFileLabels: [],
+        };
+    }
+    const modelLabels = [];
+    const fileLabels = [];
+    const seenModels = new Set();
+    const seenFiles = new Set();
+    const threadEntries = [];
+    const sessionFiles = node_fs_1.default.readdirSync(projectDir, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.jsonl'))
+        .map((entry) => {
+        const fullPath = node_path_1.default.join(projectDir, entry.name);
+        const stats = node_fs_1.default.statSync(fullPath);
+        return {
+            fullPath,
+            mtimeMs: stats.mtimeMs,
+        };
+    })
+        .sort((left, right) => right.mtimeMs - left.mtimeMs)
+        .slice(0, MAX_ACTIVITY_THREADS);
+    const seenThreads = new Set();
+    for (const sessionFile of sessionFiles) {
+        const summary = summarizeClaudeSessionFile(sessionFile.fullPath, folderScope, repo.rootPath);
+        if (summary.thread) {
+            const key = `${summary.thread.provider}|${summary.thread.threadId || summary.thread.threadLabel}`;
+            if (!seenThreads.has(key)) {
+                seenThreads.add(key);
+                threadEntries.push(summary.thread);
+            }
+        }
+        for (const label of summary.modelLabels) {
+            const key = label.toLowerCase();
+            if (seenModels.has(key))
+                continue;
+            seenModels.add(key);
+            modelLabels.push(label);
+        }
+        for (const label of summary.fileLabels) {
+            const key = label.toLowerCase();
+            if (seenFiles.has(key))
+                continue;
+            seenFiles.add(key);
+            fileLabels.push(label);
+            if (fileLabels.length >= MAX_ACTIVITY_FILE_LABELS)
+                break;
+        }
+        if (threadEntries.length >= MAX_ACTIVITY_THREADS)
+            break;
+    }
+    return {
+        threads: threadEntries,
+        modelLabels,
+        fileLabels,
+        scopeFileLabels: [],
+    };
+}
+//# sourceMappingURL=runtime-editor-activity.js.map