devchain-cli 0.23.4 → 0.24.1

package/dist/server/modules/orchestrator/sync/services/task-merge.service.js

@@ -1,698 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskMergeService = void 0;
-const common_1 = require("@nestjs/common");
-const core_1 = require("@nestjs/core");
-const event_emitter_1 = require("@nestjs/event-emitter");
-const crypto_1 = require("crypto");
-const logger_1 = require("../../../../common/logging/logger");
-const env_config_1 = require("../../../../common/config/env.config");
-const orchestrator_provider_1 = require("../../orchestrator-storage/db/orchestrator.provider");
-const schema_1 = require("../../../storage/db/schema");
-const worktrees_store_1 = require("../../worktrees/worktrees.store");
-const task_merge_events_1 = require("../events/task-merge.events");
-const sqlite_raw_1 = require("../../../storage/db/sqlite-raw");
-const transaction_runner_1 = require("../../../storage/db/transaction-runner");
-const main_project_bootstrap_service_1 = require("../../../projects/services/main-project-bootstrap.service");
-const storage_interface_1 = require("../../../storage/interfaces/storage.interface");
-const path_1 = require("path");
-const logger = (0, logger_1.createLogger)('OrchestratorTaskMergeService');
-const CONTAINER_FETCH_TIMEOUT_MS = 5_000;
-const UNKNOWN_STATUS_LABEL = 'Unknown';
-const UNKNOWN_STATUS_COLOR = '#6c757d';
-const UNKNOWN_PROFILE_LABEL = 'Unknown';
-const SQLITE_EPIC_PAGE_SIZE = 500;
-const SQLITE_STATUS_PAGE_SIZE = 500;
-const SQLITE_AGENT_PAGE_SIZE = 500;
-const MERGED_TAG_PREFIX = 'merged:';
-let TaskMergeService = class TaskMergeService {
-    store;
-    db;
-    storage;
-    mainProjectBootstrap;
-    moduleRef;
-    constructor(store, db, storage, mainProjectBootstrap, moduleRef) {
-        this.store = store;
-        this.db = db;
-        this.storage = storage;
-        this.mainProjectBootstrap = mainProjectBootstrap;
-        this.moduleRef = moduleRef;
-    }
-    async handleTaskMergeRequested(payload) {
-        return this.mergeTasksFromContainer(payload.worktreeId);
-    }
-    async mergeTasksFromContainer(worktreeId) {
-        const worktree = await this.store.getById(worktreeId);
-        if (!worktree) {
-            throw new common_1.NotFoundException(`Worktree not found: ${worktreeId}`);
-        }
-        if (!worktree.containerPort || !worktree.devchainProjectId) {
-            throw new common_1.BadRequestException(`Worktree ${worktreeId} has no active container endpoint for task extraction`);
-        }
-        const baseUrl = `http://127.0.0.1:${worktree.containerPort}`;
-        const projectId = encodeURIComponent(worktree.devchainProjectId);
-        let epicsPayload;
-        let agentsPayload;
-        let statusesPayload;
-        let profilesPayload;
-        try {
-            [epicsPayload, agentsPayload, statusesPayload, profilesPayload] = await Promise.all([
-                this.fetchContainerJson(`${baseUrl}/api/epics?projectId=${projectId}&limit=1000&type=all`),
-                this.fetchContainerJson(`${baseUrl}/api/agents?projectId=${projectId}&limit=1000`),
-                this.fetchContainerJsonSafe(`${baseUrl}/api/statuses?projectId=${projectId}&limit=1000`),
-                this.fetchProfilesForProject(baseUrl, projectId),
-            ]);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new common_1.BadRequestException(`Failed to extract task history from worktree container ${worktree.name}: ${message}`);
-        }
-        const nowIso = new Date().toISOString();
-        const epics = this.normalizeEpics(epicsPayload.items ?? []);
-        const agents = this.normalizeAgents(agentsPayload.items ?? []);
-        const agentNameById = new Map(agents.map((agent) => [agent.id, agent.name]));
-        const statusById = this.buildStatusMap(statusesPayload?.items ?? []);
-        const profileNameById = this.buildProfileMap(profilesPayload?.items ?? []);
-        const assignedEpicsByAgent = new Map();
-        for (const epic of epics) {
-            if (!epic.agentId) {
-                continue;
-            }
-            assignedEpicsByAgent.set(epic.agentId, (assignedEpicsByAgent.get(epic.agentId) ?? 0) + 1);
-        }
-        const mergedEpicRows = epics.map((epic) => {
-            const resolvedStatus = this.resolveStatus(epic.statusId, statusById);
-            return {
-                id: (0, crypto_1.randomUUID)(),
-                worktreeId: worktree.id,
-                devchainEpicId: epic.id,
-                title: epic.title,
-                description: epic.description,
-                statusName: resolvedStatus.label,
-                statusColor: resolvedStatus.color,
-                agentName: epic.agentId ? (agentNameById.get(epic.agentId) ?? null) : null,
-                parentEpicId: epic.parentId,
-                tags: epic.tags,
-                createdAtSource: epic.createdAtSource,
-                mergedAt: nowIso,
-            };
-        });
-        const mergedAgentRows = agents.map((agent) => ({
-            id: (0, crypto_1.randomUUID)(),
-            worktreeId: worktree.id,
-            devchainAgentId: agent.id,
-            name: agent.name,
-            profileName: this.resolveProfileName(agent.profileId, profileNameById),
-            epicsCompleted: agent.epicsCompleted ??
-                agent.completedEpics ??
-                agent.activityCount ??
-                assignedEpicsByAgent.get(agent.id) ??
-                0,
-            mergedAt: nowIso,
-        }));
-        await this.persistMergedRows(mergedEpicRows, mergedAgentRows);
-        const sqliteImportSummary = await this.importEpicsIntoMainProject({
-            worktreeId: worktree.id,
-            worktreeName: worktree.name,
-            epics,
-            statusById,
-            agentNameById,
-        });
-        logger.info({
-            worktreeId: worktree.id,
-            worktreeName: worktree.name,
-            epicsMerged: mergedEpicRows.length,
-            agentsMerged: mergedAgentRows.length,
-            sqliteEpicsImported: sqliteImportSummary.imported,
-            sqliteEpicsSkipped: sqliteImportSummary.skipped,
-            sqliteStatusesCreated: sqliteImportSummary.statusesCreated,
-        }, 'Merged task history from container into orchestrator storage');
-        return {
-            worktreeId: worktree.id,
-            epicsMerged: mergedEpicRows.length,
-            agentsMerged: mergedAgentRows.length,
-        };
-    }
-    async persistMergedRows(mergedEpicRows, mergedAgentRows) {
-        const persist = (targetDb) => {
-            if (mergedEpicRows.length > 0) {
-                targetDb
-                    .insert(schema_1.mergedEpics)
-                    .values(mergedEpicRows)
-                    .onConflictDoNothing({
-                    target: [schema_1.mergedEpics.worktreeId, schema_1.mergedEpics.devchainEpicId],
-                })
-                    .run();
-            }
-            if (mergedAgentRows.length > 0) {
-                targetDb
-                    .insert(schema_1.mergedAgents)
-                    .values(mergedAgentRows)
-                    .onConflictDoNothing({
-                    target: [schema_1.mergedAgents.worktreeId, schema_1.mergedAgents.devchainAgentId],
-                })
-                    .run();
-            }
-        };
-        const rawSqlite = this.resolveRawSqliteClientForOrchestratorDb();
-        if (!rawSqlite) {
-            const dbWithTransaction = this.db;
-            if (typeof dbWithTransaction.transaction === 'function') {
-                dbWithTransaction.transaction((tx) => {
-                    persist(tx);
-                });
-                return;
-            }
-            persist(this.db);
-            return;
-        }
-        await new transaction_runner_1.TransactionRunner(rawSqlite).runImmediateQueued(() => {
-            persist(this.db);
-        });
-    }
-    normalizeEpics(items) {
-        return items
-            .map((item) => {
-            const id = item.id?.trim();
-            if (!id) {
-                return null;
-            }
-            const createdAtSource = this.parseIsoDate(item.createdAt);
-            return {
-                id,
-                title: item.title?.trim() || 'Untitled Epic',
-                description: item.description ?? null,
-                statusId: item.statusId?.trim() || null,
-                parentId: item.parentId?.trim() || null,
-                agentId: item.agentId?.trim() || null,
-                tags: Array.isArray(item.tags) ? item.tags.filter((tag) => typeof tag === 'string') : [],
-                createdAtSource,
-            };
-        })
-            .filter((item) => Boolean(item));
-    }
-    buildStatusMap(items) {
-        const map = new Map();
-        for (const item of items) {
-            const id = item.id?.trim();
-            if (!id) {
-                continue;
-            }
-            const label = item.label?.trim() || `${UNKNOWN_STATUS_LABEL} (${id})`;
-            const color = this.normalizeStatusColor(item.color);
-            map.set(id, { label, color });
-        }
-        return map;
-    }
-    buildProfileMap(items) {
-        const map = new Map();
-        for (const item of items) {
-            const id = item.id?.trim();
-            if (!id) {
-                continue;
-            }
-            const name = item.name?.trim();
-            map.set(id, name && name.length > 0 ? name : `${UNKNOWN_PROFILE_LABEL} (${id})`);
-        }
-        return map;
-    }
-    resolveStatus(statusId, map) {
-        if (!statusId) {
-            return { label: UNKNOWN_STATUS_LABEL, color: UNKNOWN_STATUS_COLOR };
-        }
-        return (map.get(statusId) ?? {
-            label: `${UNKNOWN_STATUS_LABEL} (${statusId})`,
-            color: UNKNOWN_STATUS_COLOR,
-        });
-    }
-    resolveProfileName(profileId, map) {
-        if (!profileId) {
-            return UNKNOWN_PROFILE_LABEL;
-        }
-        return map.get(profileId) ?? `${UNKNOWN_PROFILE_LABEL} (${profileId})`;
-    }
-    normalizeStatusColor(color) {
-        const normalized = color?.trim();
-        if (normalized && /^#[0-9a-fA-F]{6}$/.test(normalized)) {
-            return normalized;
-        }
-        return UNKNOWN_STATUS_COLOR;
-    }
-    normalizeAgents(items) {
-        return items
-            .map((item) => {
-            const id = item.id?.trim();
-            if (!id) {
-                return null;
-            }
-            return {
-                id,
-                name: item.name?.trim() || null,
-                profileId: item.profileId?.trim() || null,
-                epicsCompleted: this.toNumberOrNull(item.epicsCompleted),
-                completedEpics: this.toNumberOrNull(item.completedEpics),
-                activityCount: this.toNumberOrNull(item.activityCount),
-            };
-        })
-            .filter((item) => Boolean(item));
-    }
-    toNumberOrNull(value) {
-        if (typeof value !== 'number' || Number.isNaN(value)) {
-            return null;
-        }
-        return Math.max(0, Math.floor(value));
-    }
-    parseIsoDate(value) {
-        if (!value) {
-            return null;
-        }
-        const parsed = new Date(value);
-        if (Number.isNaN(parsed.getTime())) {
-            return null;
-        }
-        return parsed.toISOString();
-    }
-    async fetchContainerJson(url) {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), CONTAINER_FETCH_TIMEOUT_MS);
-        try {
-            const response = await fetch(url, {
-                headers: { accept: 'application/json' },
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                throw new Error(`Container request failed with HTTP ${response.status}`);
-            }
-            return (await response.json());
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === 'AbortError') {
-                throw new Error(`Container request timed out after ${CONTAINER_FETCH_TIMEOUT_MS}ms`);
-            }
-            throw error;
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-    }
-    async fetchContainerJsonSafe(url) {
-        try {
-            return await this.fetchContainerJson(url);
-        }
-        catch (error) {
-            logger.warn({ error, url }, 'Optional container lookup failed; using fallback values');
-            return null;
-        }
-    }
-    async fetchProfilesForProject(baseUrl, projectId) {
-        const primary = await this.fetchContainerJsonSafe(`${baseUrl}/api/agent-profiles?projectId=${projectId}&limit=1000`);
-        if (primary?.items && primary.items.length > 0) {
-            return primary;
-        }
-        const fallback = await this.fetchContainerJsonSafe(`${baseUrl}/api/profiles?projectId=${projectId}&limit=1000`);
-        if (fallback?.items && fallback.items.length > 0) {
-            return fallback;
-        }
-        return primary ?? fallback;
-    }
-    async importEpicsIntoMainProject(input) {
-        if (process.env.DEVCHAIN_MODE !== 'main') {
-            return { imported: 0, skipped: input.epics.length, statusesCreated: 0 };
-        }
-        if (!this.storage) {
-            logger.warn('Main mode epic import skipped because STORAGE_SERVICE is unavailable');
-            return { imported: 0, skipped: input.epics.length, statusesCreated: 0 };
-        }
-        const targetProjectId = await this.resolveMainProjectId();
-        if (!targetProjectId) {
-            logger.warn({ worktreeId: input.worktreeId }, 'Main mode epic import skipped: no target project');
-            return { imported: 0, skipped: input.epics.length, statusesCreated: 0 };
-        }
-        const existingSourceToTarget = await this.loadExistingMergedEpicMap(targetProjectId, input.worktreeId);
-        const statusState = await this.buildStatusState(targetProjectId);
-        const mainAgentByName = await this.buildMainAgentMap(targetProjectId);
-        const mergeDateIso = new Date().toISOString();
-        const pending = new Map(input.epics
-            .filter((epic) => !existingSourceToTarget.has(epic.id))
-            .map((epic) => [epic.id, epic]));
-        let imported = 0;
-        const sourceToTargetId = new Map(existingSourceToTarget);
-        while (pending.size > 0) {
-            let progressed = false;
-            for (const [sourceEpicId, epic] of [...pending.entries()]) {
-                if (epic.parentId && pending.has(epic.parentId) && !sourceToTargetId.has(epic.parentId)) {
-                    continue;
-                }
-                const resolvedStatus = this.resolveStatus(epic.statusId, input.statusById);
-                const statusId = await this.ensureMainStatus(targetProjectId, resolvedStatus, statusState);
-                const sourceAgentName = epic.agentId
-                    ? (input.agentNameById.get(epic.agentId) ?? null)
-                    : null;
-                const mappedAgentId = sourceAgentName
-                    ? (mainAgentByName.get(sourceAgentName.trim().toLowerCase()) ?? null)
-                    : null;
-                const parentTargetId = epic.parentId && sourceToTargetId.has(epic.parentId)
-                    ? (sourceToTargetId.get(epic.parentId) ?? null)
-                    : null;
-                const mergedTags = this.buildMergedTags(epic.tags, input.worktreeName);
-                const mergeResult = await this.createMainEpicWithAtomicDedup({
-                    projectId: targetProjectId,
-                    worktreeId: input.worktreeId,
-                    sourceEpicId,
-                    createInput: {
-                        projectId: targetProjectId,
-                        title: epic.title,
-                        description: epic.description,
-                        statusId,
-                        parentId: parentTargetId,
-                        agentId: mappedAgentId,
-                        tags: mergedTags,
-                        data: {
-                            mergedFrom: {
-                                worktreeId: input.worktreeId,
-                                worktreeName: input.worktreeName,
-                                sourceEpicId,
-                                sourceParentEpicId: epic.parentId,
-                                sourceStatusId: epic.statusId,
-                                sourceAgentId: epic.agentId,
-                                sourceAgentName,
-                                mergedAt: mergeDateIso,
-                            },
-                        },
-                        skillsRequired: null,
-                    },
-                });
-                sourceToTargetId.set(sourceEpicId, mergeResult.epicId);
-                pending.delete(sourceEpicId);
-                if (mergeResult.inserted) {
-                    imported += 1;
-                }
-                progressed = true;
-            }
-            if (progressed) {
-                continue;
-            }
-            for (const [sourceEpicId, epic] of [...pending.entries()]) {
-                const resolvedStatus = this.resolveStatus(epic.statusId, input.statusById);
-                const statusId = await this.ensureMainStatus(targetProjectId, resolvedStatus, statusState);
-                const sourceAgentName = epic.agentId
-                    ? (input.agentNameById.get(epic.agentId) ?? null)
-                    : null;
-                const mappedAgentId = sourceAgentName
-                    ? (mainAgentByName.get(sourceAgentName.trim().toLowerCase()) ?? null)
-                    : null;
-                const mergedTags = this.buildMergedTags(epic.tags, input.worktreeName);
-                const mergeResult = await this.createMainEpicWithAtomicDedup({
-                    projectId: targetProjectId,
-                    worktreeId: input.worktreeId,
-                    sourceEpicId,
-                    createInput: {
-                        projectId: targetProjectId,
-                        title: epic.title,
-                        description: epic.description,
-                        statusId,
-                        parentId: null,
-                        agentId: mappedAgentId,
-                        tags: mergedTags,
-                        data: {
-                            mergedFrom: {
-                                worktreeId: input.worktreeId,
-                                worktreeName: input.worktreeName,
-                                sourceEpicId,
-                                sourceParentEpicId: epic.parentId,
-                                sourceStatusId: epic.statusId,
-                                sourceAgentId: epic.agentId,
-                                sourceAgentName,
-                                mergedAt: mergeDateIso,
-                                unresolvedParent: Boolean(epic.parentId),
-                            },
-                        },
-                        skillsRequired: null,
-                    },
-                });
-                sourceToTargetId.set(sourceEpicId, mergeResult.epicId);
-                pending.delete(sourceEpicId);
-                if (mergeResult.inserted) {
-                    imported += 1;
-                }
-            }
-            break;
-        }
-        return {
-            imported,
-            skipped: input.epics.length - imported,
-            statusesCreated: statusState.createdCount,
-        };
-    }
-    async createMainEpicWithAtomicDedup(input) {
-        if (!this.storage) {
-            throw new Error('Storage service is unavailable for main epic import');
-        }
-        const storage = this.storage;
-        const rawSqlite = this.resolveRawSqliteClientForStorage(storage);
-        if (!rawSqlite) {
-            const created = await storage.createEpic(input.createInput);
-            return { epicId: created.id, inserted: true };
-        }
-        const existingLookup = rawSqlite.prepare(`
-        SELECT e.id AS id
-        FROM epics e
-        WHERE e.project_id = ?
-          AND json_extract(json_extract(e.data, '$'), '$.mergedFrom.worktreeId') = ?
-          AND json_extract(json_extract(e.data, '$'), '$.mergedFrom.sourceEpicId') = ?
-        LIMIT 1
-      `);
-        return new transaction_runner_1.TransactionRunner(rawSqlite).runImmediateAsync(async () => {
-            const existing = existingLookup.get(input.projectId, input.worktreeId, input.sourceEpicId);
-            if (existing?.id) {
-                return { epicId: existing.id, inserted: false };
-            }
-            const created = await storage.createEpicWithinTransaction(input.createInput);
-            return { epicId: created.id, inserted: true };
-        });
-    }
-    async resolveMainProjectId() {
-        if (!this.storage) {
-            return null;
-        }
-        const bootstrapProjectId = this.resolveMainProjectBootstrapService()?.getMainProjectId();
-        if (bootstrapProjectId) {
-            return bootstrapProjectId;
-        }
-        const env = (0, env_config_1.getEnvConfig)();
-        const repoRoot = (0, path_1.resolve)(env.REPO_ROOT ?? process.cwd());
-        const existingByPath = await this.storage.findProjectByPath(repoRoot);
-        if (existingByPath) {
-            return existingByPath.id;
-        }
-        const allProjects = await this.storage.listProjects({ limit: 1000, offset: 0 });
-        if (allProjects.total > 0 && allProjects.items.length > 0) {
-            return allProjects.items[0].id;
-        }
-        const created = await this.storage.createProject({
-            name: (0, path_1.basename)(repoRoot) || 'Main',
-            description: 'Auto-created main project for merged worktree epics',
-            rootPath: repoRoot,
-            isTemplate: false,
-        });
-        return created.id;
-    }
-    resolveMainProjectBootstrapService() {
-        if (this.mainProjectBootstrap) {
-            return this.mainProjectBootstrap;
-        }
-        if (!this.moduleRef) {
-            return null;
-        }
-        try {
-            return this.moduleRef.get(main_project_bootstrap_service_1.MainProjectBootstrapService, { strict: false });
-        }
-        catch {
-            return null;
-        }
-    }
-    async buildStatusState(projectId) {
-        if (!this.storage) {
-            return {
-                byLabel: new Map(),
-                nextPosition: { value: 0 },
-                createdCount: 0,
-            };
-        }
-        const allStatuses = [];
-        let offset = 0;
-        while (true) {
-            const page = await this.storage.listStatuses(projectId, {
-                limit: SQLITE_STATUS_PAGE_SIZE,
-                offset,
-            });
-            allStatuses.push(...page.items);
-            offset += page.items.length;
-            if (offset >= page.total || page.items.length === 0) {
-                break;
-            }
-        }
-        const byLabel = new Map();
-        let maxPosition = -1;
-        for (const status of allStatuses) {
-            byLabel.set(status.label.trim().toLowerCase(), status);
-            maxPosition = Math.max(maxPosition, status.position);
-        }
-        return {
-            byLabel,
-            nextPosition: { value: maxPosition + 1 },
-            createdCount: 0,
-        };
-    }
-    async ensureMainStatus(projectId, resolvedStatus, statusState) {
-        if (!this.storage) {
-            throw new Error('Storage service is unavailable for main status mapping');
-        }
-        const normalizedLabel = resolvedStatus.label.trim().toLowerCase();
-        const existing = statusState.byLabel.get(normalizedLabel);
-        if (existing) {
-            return existing.id;
-        }
-        const created = await this.storage.createStatus({
-            projectId,
-            label: resolvedStatus.label,
-            color: resolvedStatus.color,
-            position: statusState.nextPosition.value++,
-        });
-        statusState.byLabel.set(normalizedLabel, created);
-        statusState.createdCount += 1;
-        return created.id;
-    }
-    async buildMainAgentMap(projectId) {
-        if (!this.storage) {
-            return new Map();
-        }
-        const byName = new Map();
-        let offset = 0;
-        while (true) {
-            const page = await this.storage.listAgents(projectId, {
-                limit: SQLITE_AGENT_PAGE_SIZE,
-                offset,
-            });
-            for (const agent of page.items) {
-                const normalized = agent.name.trim().toLowerCase();
-                if (!byName.has(normalized)) {
-                    byName.set(normalized, agent.id);
-                }
-            }
-            offset += page.items.length;
-            if (offset >= page.total || page.items.length === 0) {
-                break;
-            }
-        }
-        return byName;
-    }
-    async loadExistingMergedEpicMap(projectId, worktreeId) {
-        if (!this.storage) {
-            return new Map();
-        }
-        const sourceToTarget = new Map();
-        let offset = 0;
-        while (true) {
-            const page = await this.storage.listProjectEpics(projectId, {
-                type: 'all',
-                limit: SQLITE_EPIC_PAGE_SIZE,
-                offset,
-            });
-            for (const epic of page.items) {
-                const sourceEpicId = this.extractSourceEpicId(epic, worktreeId);
-                if (sourceEpicId && !sourceToTarget.has(sourceEpicId)) {
-                    sourceToTarget.set(sourceEpicId, epic.id);
-                }
-            }
-            offset += page.items.length;
-            if (offset >= page.total || page.items.length === 0) {
-                break;
-            }
-        }
-        return sourceToTarget;
-    }
-    extractSourceEpicId(epic, worktreeId) {
-        const data = epic.data;
-        if (data && typeof data === 'object' && 'mergedFrom' in data) {
-            const mergedFrom = data.mergedFrom;
-            if (mergedFrom && typeof mergedFrom === 'object') {
-                const mergedWorktreeId = mergedFrom.worktreeId;
-                const sourceEpicId = mergedFrom.sourceEpicId;
-                if (typeof mergedWorktreeId === 'string' &&
-                    mergedWorktreeId === worktreeId &&
-                    typeof sourceEpicId === 'string' &&
-                    sourceEpicId.trim().length > 0) {
-                    return sourceEpicId.trim();
-                }
-            }
-        }
-        return null;
-    }
-    resolveRawSqliteClientForStorage(storage) {
-        const storageWithDb = storage;
-        if (!storageWithDb.db) {
-            return null;
-        }
-        try {
-            return (0, sqlite_raw_1.getRawSqliteClient)(storageWithDb.db);
-        }
-        catch {
-            return null;
-        }
-    }
-    resolveRawSqliteClientForOrchestratorDb() {
-        try {
-            const raw = (0, sqlite_raw_1.getRawSqliteClient)(this.db);
-            if (!raw || typeof raw.exec !== 'function') {
-                return null;
-            }
-            return raw;
-        }
-        catch {
-            return null;
-        }
-    }
-    buildMergedTags(sourceTags, worktreeName) {
-        const tags = new Set();
-        for (const tag of sourceTags) {
-            const trimmed = tag.trim();
-            if (trimmed.length > 0) {
-                tags.add(trimmed);
-            }
-        }
-        tags.add(`${MERGED_TAG_PREFIX}${worktreeName}`);
-        return [...tags];
-    }
-};
-exports.TaskMergeService = TaskMergeService;
-__decorate([
-    (0, event_emitter_1.OnEvent)(task_merge_events_1.WORKTREE_TASK_MERGE_REQUESTED_EVENT, { async: true }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], TaskMergeService.prototype, "handleTaskMergeRequested", null);
-exports.TaskMergeService = TaskMergeService = __decorate([
-    (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Inject)(worktrees_store_1.WORKTREES_STORE)),
-    __param(1, (0, common_1.Inject)(orchestrator_provider_1.ORCHESTRATOR_DB_CONNECTION)),
-    __param(2, (0, common_1.Optional)()),
-    __param(2, (0, common_1.Inject)(storage_interface_1.STORAGE_SERVICE)),
-    __param(3, (0, common_1.Optional)()),
-    __param(4, (0, common_1.Optional)()),
-    __metadata("design:paramtypes", [Object, Object, Object, main_project_bootstrap_service_1.MainProjectBootstrapService,
-        core_1.ModuleRef])
-], TaskMergeService);
-//# sourceMappingURL=task-merge.service.js.map