sudocode 1.1.18-dev.0 → 1.1.18

package/node_modules/@sudocode-ai/cli/dist/import.js

@@ -1,751 +0,0 @@
-/**
- * Import JSONL data to SQLite with collision resolution
- */
-import { readJSONL } from "./jsonl.js";
-import { listSpecs, createSpec, updateSpec, deleteSpec, getSpec, } from "./operations/specs.js";
-import { listIssues, createIssue, updateIssue, deleteIssue, getIssue, } from "./operations/issues.js";
-import { addRelationship, removeOutgoingRelationships, } from "./operations/relationships.js";
-import { setTags } from "./operations/tags.js";
-import { createFeedback, listFeedback, deleteFeedback, } from "./operations/feedback.js";
-import { transaction } from "./operations/transactions.js";
-import * as path from "path";
-import * as fs from "fs";
-/**
- * Detect changes between existing and incoming entities
- * Uses UUID as the source of truth for entity identity
- */
-export function detectChanges(existing, incoming, forceUpdateIds = []) {
-    // Map by UUID (the true identity)
-    const existingByUUID = new Map(existing.map((e) => [e.uuid, e]));
-    const incomingUUIDs = new Set(incoming.map((e) => e.uuid));
-    const forceUpdateSet = new Set(forceUpdateIds);
-    const added = incoming
-        .filter((e) => !existingByUUID.has(e.uuid))
-        .map((e) => e.id);
-    const deleted = existing
-        .filter((e) => !incomingUUIDs.has(e.uuid))
-        .map((e) => e.id);
-    const updated = [];
-    const unchanged = [];
-    for (const inc of incoming) {
-        const ex = existingByUUID.get(inc.uuid);
-        if (ex) {
-            // Same entity (same UUID), check if content changed or force update requested
-            if (forceUpdateSet.has(inc.id) || hasChanged(ex, inc)) {
-                updated.push(inc.id);
-            }
-            else {
-                unchanged.push(inc.id);
-            }
-        }
-    }
-    return { added, updated, deleted, unchanged };
-}
-/**
- * Check if an entity has changed
- */
-function hasChanged(existing, incoming) {
-    // Simple comparison based on updated_at timestamp
-    return existing.updated_at !== incoming.updated_at;
-}
-/**
- * Detect ID collisions (same ID, different UUID)
- * UUIDs are the source of truth for entity identity
- */
-export function detectCollisions(existing, incoming) {
-    const collisions = [];
-    const existingMap = new Map(existing.map((e) => [e.id, e]));
-    // First, detect collisions between existing and incoming
-    for (const inc of incoming) {
-        const ex = existingMap.get(inc.id);
-        // Collision only if same ID but different UUID (different entities)
-        if (ex && ex.uuid !== inc.uuid) {
-            collisions.push({
-                id: inc.id,
-                uuid: inc.uuid, // UUID of the incoming entity
-                type: "spec", // Will be set correctly by caller
-                reason: "Same ID but different UUID (different entities)",
-                localContent: ex.title,
-                incomingContent: inc.title,
-                localCreatedAt: ex.created_at,
-                incomingCreatedAt: inc.created_at,
-            });
-        }
-    }
-    // Second, detect collisions within incoming data itself (duplicates)
-    const incomingByID = new Map();
-    for (const inc of incoming) {
-        const existing = incomingByID.get(inc.id) || [];
-        existing.push(inc);
-        incomingByID.set(inc.id, existing);
-    }
-    for (const [id, entities] of incomingByID.entries()) {
-        if (entities.length > 1) {
-            // Multiple entities with same ID in incoming data
-            // Check if they have different UUIDs (real collision) vs same UUID (duplicate entry)
-            const uniqueUUIDs = new Set(entities.map((e) => e.uuid));
-            if (uniqueUUIDs.size > 1) {
-                // Different UUIDs = real collision within incoming data
-                // We'll keep the first one and mark the rest as collisions
-                for (let i = 1; i < entities.length; i++) {
-                    collisions.push({
-                        id: entities[i].id,
-                        uuid: entities[i].uuid, // UUID of the colliding entity
-                        type: "spec", // Will be set correctly by caller
-                        reason: "Duplicate ID in incoming data with different UUID",
-                        localContent: entities[0].title,
-                        incomingContent: entities[i].title,
-                        localCreatedAt: entities[0].created_at,
-                        incomingCreatedAt: entities[i].created_at,
-                    });
-                }
-            }
-        }
-    }
-    return collisions;
-}
-/**
- * Count references to an entity ID in content fields
- */
-export function countReferences(db, entityId, entityType) {
-    let count = 0;
-    // Count in specs
-    const specs = listSpecs(db);
-    for (const spec of specs) {
-        const regex = new RegExp(`\\b${entityId}\\b`, "g");
-        const matches = spec.content.match(regex);
-        if (matches) {
-            count += matches.length;
-        }
-    }
-    // Count in issues
-    const issues = listIssues(db);
-    for (const issue of issues) {
-        const regex = new RegExp(`\\b${entityId}\\b`, "g");
-        const contentMatches = issue.content.match(regex);
-        if (contentMatches)
-            count += contentMatches.length;
-    }
-    return count;
-}
-/**
- * Resolve collisions using timestamp-based deterministic strategy
- *
- * The entity with the NEWER (more recent) created_at timestamp logically
- * should be renumbered, while the OLDER entity keeps the original ID.
- *
- * For practical reasons (entities already in DB can't be easily renamed),
- * incoming entities are always the ones that get new IDs. However, we
- * deterministically decide which UUID gets which new ID based on timestamps.
- */
-export function resolveCollisions(db, collisions) {
-    const resolved = [];
-    const uuidToNewId = new Map();
-    for (const collision of collisions) {
-        // Determine which entity is newer based on created_at timestamps
-        let incomingIsNewer = true;
-        if (collision.localCreatedAt) {
-            const localTime = new Date(collision.localCreatedAt).getTime();
-            const incomingTime = new Date(collision.incomingCreatedAt).getTime();
-            // Check which is newer
-            if (incomingTime > localTime) {
-                incomingIsNewer = true; // Incoming is newer
-            }
-            else if (localTime > incomingTime) {
-                incomingIsNewer = false; // Local is newer
-            }
-            else {
-                // Same timestamp - use UUID comparison for determinism
-                incomingIsNewer = collision.uuid > collision.localContent;
-            }
-        }
-        // Generate deterministic new ID
-        // Always renumber the incoming entity (practical constraint)
-        // But ensure same UUID always gets same new ID across runs
-        let newId = uuidToNewId.get(collision.uuid);
-        if (!newId) {
-            newId = generateNewId(db, collision.id, collision.type);
-            uuidToNewId.set(collision.uuid, newId);
-        }
-        resolved.push({
-            ...collision,
-            resolution: "renumber", // Incoming always gets renumbered
-            newId,
-            // Track which one was logically newer (for logging/debugging)
-            ...(incomingIsNewer && {
-                note: "incoming is newer - correctly renumbered",
-            }),
-            ...(!incomingIsNewer && {
-                note: "local is newer - incoming (older) being renumbered",
-            }),
-        });
-    }
-    return resolved;
-}
-/**
- * Generate a new unique ID
- */
-function generateNewId(db, oldId, type) {
-    // Extract prefix and number
-    const match = oldId.match(/^([a-z]+-)?(\d+)$/i);
-    if (!match) {
-        // Use timestamp-based ID
-        return `${type}-${Date.now()}`;
-    }
-    const prefix = match[1] || `${type}-`;
-    let num = parseInt(match[2], 10);
-    // Find next available ID
-    let newId = `${prefix}${num + 1000}`;
-    let attempts = 0;
-    while (attempts < 1000) {
-        const exists = type === "spec"
-            ? getSpec(db, newId) !== null
-            : getIssue(db, newId) !== null;
-        if (!exists) {
-            return newId;
-        }
-        num++;
-        newId = `${prefix}${num + 1000}`;
-        attempts++;
-    }
-    // Fallback to timestamp
-    return `${prefix}${Date.now()}`;
-}
-/**
- * Update text references when an ID is renumbered
- */
-export function updateTextReferences(db, oldId, newId) {
-    let updatedCount = 0;
-    // Update specs
-    const specs = listSpecs(db);
-    for (const spec of specs) {
-        const regex = new RegExp(`\\b${oldId}\\b`, "g");
-        if (regex.test(spec.content)) {
-            const newContent = spec.content.replace(regex, newId);
-            updateSpec(db, spec.id, {
-                content: newContent,
-            });
-            updatedCount++;
-        }
-    }
-    // Update issues
-    const issues = listIssues(db);
-    for (const issue of issues) {
-        const regex = new RegExp(`\\b${oldId}\\b`, "g");
-        let updated = false;
-        let newContent = issue.content;
-        if (regex.test(issue.content)) {
-            newContent = issue.content.replace(regex, newId);
-            updated = true;
-        }
-        if (updated) {
-            updateIssue(db, issue.id, {
-                content: newContent,
-            });
-            updatedCount++;
-        }
-    }
-    return updatedCount;
-}
-/**
- * Import specs from JSONL
- */
-export function importSpecs(db, specs, changes, dryRun = false, skipRelationships = false) {
-    if (dryRun) {
-        return {
-            added: changes.added.length,
-            updated: changes.updated.length,
-            deleted: changes.deleted.length,
-        };
-    }
-    let added = 0;
-    let updated = 0;
-    let deleted = 0;
-    // Add new specs (first pass: without parent_id to handle out-of-order parents)
-    const specsWithParents = [];
-    for (const id of changes.added) {
-        const spec = specs.find((s) => s.id === id);
-        if (spec) {
-            createSpec(db, {
-                id: spec.id,
-                uuid: spec.uuid,
-                title: spec.title,
-                file_path: spec.file_path,
-                content: spec.content,
-                priority: spec.priority,
-                // Skip parent_id in first pass - will be set in second pass
-                archived: spec.archived,
-                archived_at: spec.archived_at,
-                created_at: spec.created_at,
-                updated_at: spec.updated_at,
-                // Pass null when JSONL doesn't have external_links, so SQLite gets cleared
-                // (undefined would skip the update, causing oscillation with export)
-                external_links: spec.external_links && spec.external_links.length > 0
-                    ? JSON.stringify(spec.external_links)
-                    : null,
-            });
-            // Add tags
-            setTags(db, spec.id, "spec", spec.tags || []);
-            added++;
-            // Track specs with parent_id for second pass
-            if (spec.parent_id) {
-                specsWithParents.push(spec);
-            }
-        }
-    }
-    // Second pass: set parent_id for newly added specs (now all parents exist)
-    for (const spec of specsWithParents) {
-        updateSpec(db, spec.id, {
-            parent_id: spec.parent_id,
-        });
-    }
-    // Add relationships
-    if (!skipRelationships) {
-        for (const id of changes.added) {
-            const spec = specs.find((s) => s.id === id);
-            if (spec) {
-                if (spec.relationships && spec.relationships.length > 0) {
-                    for (const rel of spec.relationships) {
-                        addRelationship(db, {
-                            from_id: rel.from,
-                            from_type: rel.from_type,
-                            to_id: rel.to,
-                            to_type: rel.to_type,
-                            relationship_type: rel.type,
-                        });
-                    }
-                }
-            }
-        }
-    }
-    // Update existing specs
-    for (const id of changes.updated) {
-        const spec = specs.find((s) => s.id === id);
-        if (spec) {
-            updateSpec(db, spec.id, {
-                title: spec.title,
-                file_path: spec.file_path,
-                content: spec.content,
-                priority: spec.priority,
-                parent_id: spec.parent_id,
-                archived: spec.archived,
-                archived_at: spec.archived_at,
-                updated_at: spec.updated_at,
-                // Pass null when JSONL doesn't have external_links, so SQLite gets cleared
-                // (undefined would skip the update, causing oscillation with export)
-                external_links: spec.external_links && spec.external_links.length > 0
-                    ? JSON.stringify(spec.external_links)
-                    : null,
-            });
-            setTags(db, spec.id, "spec", spec.tags || []);
-            updated++;
-        }
-    }
-    // Update relationships (only remove outgoing to preserve incoming relationships)
-    if (!skipRelationships) {
-        for (const id of changes.updated) {
-            const spec = specs.find((s) => s.id === id);
-            if (spec) {
-                removeOutgoingRelationships(db, spec.id, "spec");
-                for (const rel of spec.relationships || []) {
-                    addRelationship(db, {
-                        from_id: rel.from,
-                        from_type: rel.from_type,
-                        to_id: rel.to,
-                        to_type: rel.to_type,
-                        relationship_type: rel.type,
-                    });
-                }
-            }
-        }
-    }
-    // Delete removed specs
-    for (const id of changes.deleted) {
-        deleteSpec(db, id);
-        deleted++;
-    }
-    return { added, updated, deleted };
-}
-/**
- * Sync feedback for an issue from JSONL data
- */
-function syncIssueFeedback(db, issueId, feedbackJSONL) {
-    // Delete all existing feedback for this issue
-    const existingFeedback = listFeedback(db, { from_id: issueId });
-    for (const fb of existingFeedback) {
-        deleteFeedback(db, fb.id);
-    }
-    // Create new feedback from JSONL
-    if (feedbackJSONL && feedbackJSONL.length > 0) {
-        for (const fb of feedbackJSONL) {
-            // Support legacy JSONL format (issue_id/spec_id) for backward compatibility
-            const fromId = fb.from_id || fb.issue_id;
-            const toId = fb.to_id || fb.spec_id;
-            // to_id is required, but from_id is optional (external feedback)
-            if (!toId) {
-                console.warn(`Skipping feedback ${fb.id}: missing to_id or spec_id`);
-                continue;
-            }
-            createFeedback(db, {
-                id: fb.id,
-                from_id: fromId, // Can be undefined for anonymous feedback
-                to_id: toId,
-                feedback_type: fb.feedback_type,
-                content: fb.content,
-                agent: fb.agent,
-                anchor: fb.anchor,
-                dismissed: fb.dismissed,
-                created_at: fb.created_at,
-                updated_at: fb.updated_at,
-            });
-        }
-    }
-}
-/**
- * Import issues from JSONL
- */
-export function importIssues(db, issues, changes, dryRun = false, skipRelationships = false) {
-    if (dryRun) {
-        return {
-            added: changes.added.length,
-            updated: changes.updated.length,
-            deleted: changes.deleted.length,
-        };
-    }
-    let added = 0;
-    let updated = 0;
-    let deleted = 0;
-    // Add new issues (first pass: without parent_id to handle out-of-order parents)
-    const issuesWithParents = [];
-    for (const id of changes.added) {
-        const issue = issues.find((i) => i.id === id);
-        if (issue) {
-            createIssue(db, {
-                id: issue.id,
-                uuid: issue.uuid,
-                title: issue.title,
-                content: issue.content,
-                status: issue.status,
-                priority: issue.priority,
-                assignee: issue.assignee,
-                // Skip parent_id in first pass - will be set in second pass
-                archived: issue.archived,
-                archived_at: issue.archived_at,
-                created_at: issue.created_at,
-                updated_at: issue.updated_at,
-                closed_at: issue.closed_at,
-                // Pass null when JSONL doesn't have external_links, so SQLite gets cleared
-                // (undefined would skip the update, causing oscillation with export)
-                external_links: issue.external_links && issue.external_links.length > 0
-                    ? JSON.stringify(issue.external_links)
-                    : null,
-            });
-            setTags(db, issue.id, "issue", issue.tags || []);
-            added++;
-            // Track issues with parent_id for second pass
-            if (issue.parent_id) {
-                issuesWithParents.push(issue);
-            }
-        }
-    }
-    // Second pass: set parent_id for newly added issues (now all parents exist)
-    for (const issue of issuesWithParents) {
-        updateIssue(db, issue.id, {
-            parent_id: issue.parent_id,
-        });
-    }
-    // Add relationships
-    if (!skipRelationships) {
-        for (const id of changes.added) {
-            const issue = issues.find((i) => i.id === id);
-            if (issue) {
-                for (const rel of issue.relationships || []) {
-                    addRelationship(db, {
-                        from_id: rel.from,
-                        from_type: rel.from_type,
-                        to_id: rel.to,
-                        to_type: rel.to_type,
-                        relationship_type: rel.type,
-                    });
-                }
-            }
-        }
-    }
-    // Update existing issues
-    for (const id of changes.updated) {
-        const issue = issues.find((i) => i.id === id);
-        if (issue) {
-            updateIssue(db, issue.id, {
-                title: issue.title,
-                content: issue.content,
-                status: issue.status,
-                priority: issue.priority,
-                assignee: issue.assignee,
-                parent_id: issue.parent_id,
-                archived: issue.archived,
-                archived_at: issue.archived_at,
-                updated_at: issue.updated_at,
-                closed_at: issue.closed_at,
-                // Pass null when JSONL doesn't have external_links, so SQLite gets cleared
-                // (undefined would skip the update, causing oscillation with export)
-                external_links: issue.external_links && issue.external_links.length > 0
-                    ? JSON.stringify(issue.external_links)
-                    : null,
-            });
-            setTags(db, issue.id, "issue", issue.tags || []);
-            updated++;
-        }
-    }
-    // Update relationships (only remove outgoing to preserve incoming relationships)
-    if (!skipRelationships) {
-        for (const id of changes.updated) {
-            const issue = issues.find((i) => i.id === id);
-            if (issue) {
-                removeOutgoingRelationships(db, issue.id, "issue");
-                for (const rel of issue.relationships || []) {
-                    addRelationship(db, {
-                        from_id: rel.from,
-                        from_type: rel.from_type,
-                        to_id: rel.to,
-                        to_type: rel.to_type,
-                        relationship_type: rel.type,
-                    });
-                }
-            }
-        }
-    }
-    // Delete removed issues
-    for (const id of changes.deleted) {
-        deleteIssue(db, id);
-        deleted++;
-    }
-    // Sync feedback after all issues/specs are created/updated
-    // This ensures that feedback references to other issues are valid
-    for (const id of [...changes.added, ...changes.updated]) {
-        const issue = issues.find((i) => i.id === id);
-        if (issue) {
-            syncIssueFeedback(db, issue.id, issue.feedback);
-        }
-    }
-    return { added, updated, deleted };
-}
-/**
- * Import both specs and issues from JSONL files
- */
-export async function importFromJSONL(db, options = {}) {
-    const { inputDir = ".sudocode", specsFile = "specs.jsonl", issuesFile = "issues.jsonl", dryRun = false, resolveCollisions: shouldResolve = true, forceUpdateIds = [], } = options;
-    const specsPath = path.join(inputDir, specsFile);
-    const issuesPath = path.join(inputDir, issuesFile);
-    // Read JSONL files
-    const incomingSpecs = await readJSONL(specsPath, {
-        skipErrors: true,
-    });
-    const incomingIssues = await readJSONL(issuesPath, {
-        skipErrors: true,
-    });
-    // Get existing data
-    const existingSpecs = listSpecs(db);
-    const existingIssues = listIssues(db);
-    // Detect collisions
-    const specCollisions = detectCollisions(existingSpecs, incomingSpecs);
-    const issueCollisions = detectCollisions(existingIssues, incomingIssues);
-    const allCollisions = [
-        ...specCollisions.map((c) => ({ ...c, type: "spec" })),
-        ...issueCollisions.map((c) => ({ ...c, type: "issue" })),
-    ];
-    // Resolve collisions if requested
-    let resolvedCollisions = [];
-    if (shouldResolve && allCollisions.length > 0) {
-        resolvedCollisions = resolveCollisions(db, allCollisions);
-        // Modify incoming data to use new IDs for colliding entities
-        // Use UUID to identify the correct entity to rename (in case of duplicate IDs)
-        for (const collision of resolvedCollisions) {
-            if (collision.resolution === "renumber" && collision.newId) {
-                const oldId = collision.id;
-                const newId = collision.newId;
-                if (collision.type === "spec") {
-                    const spec = incomingSpecs.find((s) => s.id === oldId && s.uuid === collision.uuid);
-                    if (spec) {
-                        spec.id = newId;
-                    }
-                    // Update feedback references to this spec (to_id)
-                    for (const issue of incomingIssues) {
-                        if (issue.feedback) {
-                            for (const fb of issue.feedback) {
-                                const feedbackToId = fb.to_id || fb.spec_id;
-                                if (feedbackToId === oldId) {
-                                    // Update both old and new field names for safety
-                                    if (fb.to_id)
-                                        fb.to_id = newId;
-                                    if (fb.spec_id)
-                                        fb.spec_id = newId;
-                                }
-                            }
-                        }
-                    }
-                }
-                else if (collision.type === "issue") {
-                    const issue = incomingIssues.find((i) => i.id === oldId && i.uuid === collision.uuid);
-                    if (issue) {
-                        issue.id = newId;
-                        // Update feedback within this issue (from_id)
-                        if (issue.feedback) {
-                            for (const fb of issue.feedback) {
-                                // Update both old and new field names for safety
-                                if (fb.from_id)
-                                    fb.from_id = newId;
-                                if (fb.issue_id)
-                                    fb.issue_id = newId;
-                            }
-                        }
-                    }
-                    // Update feedback references FROM this issue in other issues' feedback
-                    for (const otherIssue of incomingIssues) {
-                        if (otherIssue.feedback) {
-                            for (const fb of otherIssue.feedback) {
-                                const feedbackFromId = fb.from_id || fb.issue_id;
-                                if (feedbackFromId === oldId) {
-                                    // Update both old and new field names for safety
-                                    if (fb.from_id)
-                                        fb.from_id = newId;
-                                    if (fb.issue_id)
-                                        fb.issue_id = newId;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    // Detect changes (after collision resolution has modified incoming data)
-    const specChanges = detectChanges(existingSpecs, incomingSpecs, forceUpdateIds);
-    const issueChanges = detectChanges(existingIssues, incomingIssues, forceUpdateIds);
-    // Collect markdown file paths for entities to be deleted (before deletion)
-    // We need to do this before the transaction because the entities will be gone after
-    const markdownFilesToDelete = [];
-    if (!dryRun) {
-        // Collect spec file paths
-        for (const id of specChanges.deleted) {
-            const spec = getSpec(db, id);
-            if (spec && spec.file_path) {
-                markdownFilesToDelete.push(path.join(inputDir, spec.file_path));
-            }
-        }
-        // Collect issue file paths (issues use standard path format)
-        for (const id of issueChanges.deleted) {
-            markdownFilesToDelete.push(path.join(inputDir, "issues", `${id}.md`));
-        }
-    }
-    // Apply changes in transaction
-    const result = {
-        specs: { added: 0, updated: 0, deleted: 0 },
-        issues: { added: 0, updated: 0, deleted: 0 },
-        collisions: resolvedCollisions.length > 0 ? resolvedCollisions : allCollisions,
-        warnings: [],
-    };
-    // Helper to try adding a relationship, collecting warnings for missing entities
-    const tryAddRelationship = (rel, sourceEntityId) => {
-        try {
-            addRelationship(db, {
-                from_id: rel.from,
-                from_type: rel.from_type,
-                to_id: rel.to,
-                to_type: rel.to_type,
-                relationship_type: rel.type,
-            });
-        }
-        catch (error) {
-            // Check if this is a "not found" error for missing entities
-            const message = error?.message || String(error);
-            if (message.includes("not found:")) {
-                result.warnings.push({
-                    type: "missing_entity",
-                    message: `Skipping relationship: ${message}`,
-                    entityId: sourceEntityId,
-                    relationshipFrom: rel.from,
-                    relationshipTo: rel.to,
-                });
-            }
-            else {
-                // Re-throw other errors
-                throw error;
-            }
-        }
-    };
-    if (!dryRun) {
-        transaction(db, () => {
-            // First pass: Import all entities without relationships
-            result.specs = importSpecs(db, incomingSpecs, specChanges, dryRun, true);
-            result.issues = importIssues(db, incomingIssues, issueChanges, dryRun, true);
-            // Second pass: Import all relationships after all entities exist
-            // Import spec relationships for added specs
-            for (const id of specChanges.added) {
-                const spec = incomingSpecs.find((s) => s.id === id);
-                if (spec && spec.relationships && spec.relationships.length > 0) {
-                    for (const rel of spec.relationships) {
-                        tryAddRelationship(rel, id);
-                    }
-                }
-            }
-            // Import spec relationships for updated specs (only remove outgoing to preserve incoming)
-            for (const id of specChanges.updated) {
-                const spec = incomingSpecs.find((s) => s.id === id);
-                if (spec) {
-                    removeOutgoingRelationships(db, spec.id, "spec");
-                    for (const rel of spec.relationships || []) {
-                        tryAddRelationship(rel, id);
-                    }
-                }
-            }
-            // Import issue relationships for added issues
-            for (const id of issueChanges.added) {
-                const issue = incomingIssues.find((i) => i.id === id);
-                if (issue && issue.relationships && issue.relationships.length > 0) {
-                    for (const rel of issue.relationships) {
-                        tryAddRelationship(rel, id);
-                    }
-                }
-            }
-            // Import issue relationships for updated issues (only remove outgoing to preserve incoming)
-            for (const id of issueChanges.updated) {
-                const issue = incomingIssues.find((i) => i.id === id);
-                if (issue) {
-                    removeOutgoingRelationships(db, issue.id, "issue");
-                    for (const rel of issue.relationships || []) {
-                        tryAddRelationship(rel, id);
-                    }
-                }
-            }
-            // Note: Text reference updating is intentionally not done here
-            // The renumbered entity is imported with its new ID
-            // References within the imported data should already be using the correct IDs
-            // Updating all references globally would incorrectly change references to the local entity
-        });
-        // Clean up markdown files for deleted entities (after successful DB transaction)
-        for (const filePath of markdownFilesToDelete) {
-            if (fs.existsSync(filePath)) {
-                try {
-                    fs.unlinkSync(filePath);
-                }
-                catch (err) {
-                    // Log but don't fail - file cleanup is best-effort
-                    console.warn(`Failed to delete markdown file: ${filePath}`, err);
-                }
-            }
-        }
-    }
-    else {
-        result.specs = importSpecs(db, incomingSpecs, specChanges, dryRun);
-        result.issues = importIssues(db, incomingIssues, issueChanges, dryRun);
-    }
-    // Log warnings for skipped relationships (non-fatal issues)
-    if (result.warnings && result.warnings.length > 0) {
-        console.warn(`[Import] ${result.warnings.length} relationship(s) skipped due to missing entities:`);
-        for (const warning of result.warnings) {
-            console.warn(`  - ${warning.message}`);
-        }
-    }
-    return result;
-}
-//# sourceMappingURL=import.js.map