sudocode 1.1.20 → 1.1.22

package/node_modules/@sudocode-ai/local-server/dist/routes/import.js

@@ -1,896 +0,0 @@
-/**
- * Server routes for on-demand import functionality
- *
- * Provides API endpoints for importing entities from external systems
- * into sudocode specs via URL-based on-demand import.
- */
-import { Router } from "express";
-import { createHash } from "crypto";
-import { existsSync, readFileSync } from "fs";
-import * as path from "path";
-import { loadPlugin, getFirstPartyPlugins, testProviderConnection, } from "@sudocode-ai/cli/dist/integrations/index.js";
-import { findSpecsByExternalLink, findIssuesByExternalLink, createSpecFromExternal, } from "@sudocode-ai/cli/dist/operations/external-links.js";
-import { createIssue } from "@sudocode-ai/cli/dist/operations/issues.js";
-import { createFeedback } from "@sudocode-ai/cli/dist/operations/feedback.js";
-import { generateIssueId } from "@sudocode-ai/cli/dist/id-generator.js";
-import { triggerExport, syncEntityToMarkdown } from "../services/export.js";
-import { broadcastSpecUpdate } from "../services/websocket.js";
-import { bulkRefresh, } from "../services/external-refresh-service.js";
-/**
- * Helper to read config.json
- */
-function readConfig(sudocodeDir) {
-    const configPath = path.join(sudocodeDir, "config.json");
-    if (!existsSync(configPath)) {
-        return {};
-    }
-    return JSON.parse(readFileSync(configPath, "utf-8"));
-}
-/**
- * Compute SHA256 hash of content for change detection
- */
-function computeContentHash(title, content) {
-    const hash = createHash("sha256");
-    hash.update(title);
-    hash.update(content || "");
-    return hash.digest("hex");
-}
-/**
- * Format a comment for import as IssueFeedback content
- */
-function formatImportedComment(comment) {
-    const dateStr = new Date(comment.created_at).toLocaleDateString("en-US", {
-        year: "numeric",
-        month: "short",
-        day: "numeric",
-    });
-    let content = `**@${comment.author}** commented on ${dateStr}:\n\n${comment.body}`;
-    if (comment.url) {
-        content += `\n\n---\n*Imported from [${comment.url}](${comment.url})*`;
-    }
-    return content;
-}
-/**
- * Check if a provider supports on-demand import
- */
-function isOnDemandCapable(provider) {
-    return provider.supportsOnDemandImport === true;
-}
-/**
- * Get URL patterns from a provider (if available)
- */
-function getProviderUrlPatterns(provider) {
-    // Try to get URL patterns from the provider
-    // Some providers may expose this information
-    if ("urlPatterns" in provider) {
-        return provider.urlPatterns;
-    }
-    // Default patterns based on known providers
-    const defaultPatterns = {
-        github: [
-            "https://github.com/{owner}/{repo}/issues/{number}",
-            "https://github.com/{owner}/{repo}/discussions/{number}",
-        ],
-        beads: ["beads://{workspace}/{id}"],
-        jira: ["https://{domain}.atlassian.net/browse/{key}"],
-    };
-    return defaultPatterns[provider.name] || [];
-}
-/**
- * Determine auth method for a provider
- */
-function getProviderAuthMethod(providerName) {
-    // Known auth methods for providers
-    const authMethods = {
-        github: "gh-cli",
-        jira: "token",
-        beads: "none",
-    };
-    return authMethods[providerName] || "token";
-}
-export function createImportRouter() {
-    const router = Router();
-    /**
-     * GET /api/import/providers - List available import providers
-     *
-     * Returns all configured providers that support on-demand import
-     */
-    router.get("/providers", async (req, res) => {
-        try {
-            const firstPartyPlugins = getFirstPartyPlugins();
-            const config = readConfig(req.project.sudocodeDir);
-            const integrations = (config.integrations || {});
-            const providers = [];
-            // Check first-party plugins
-            for (const p of firstPartyPlugins) {
-                const providerConfig = integrations[p.name];
-                const plugin = await loadPlugin(p.name);
-                if (!plugin) {
-                    continue;
-                }
-                // Create provider to check capabilities
-                try {
-                    const provider = plugin.createProvider(providerConfig?.options || {}, req.project.path);
-                    // Only include providers that support on-demand import
-                    if (provider.supportsOnDemandImport) {
-                        // Test if configured (has auth, etc.)
-                        const testResult = await testProviderConnection(p.name, providerConfig || { enabled: false }, req.project.path);
-                        providers.push({
-                            name: p.name,
-                            displayName: plugin.displayName,
-                            supportsOnDemandImport: true,
-                            supportsSearch: provider.supportsSearch,
-                            urlPatterns: getProviderUrlPatterns(provider),
-                            configured: testResult.configured,
-                            authMethod: getProviderAuthMethod(p.name),
-                        });
-                    }
-                }
-                catch (error) {
-                    // Provider creation failed - skip
-                    console.warn(`[import] Failed to create provider ${p.name}:`, error);
-                }
-            }
-            // Also check custom plugins from config
-            const firstPartyNames = new Set(firstPartyPlugins.map((p) => p.name));
-            for (const [name, providerConfig] of Object.entries(integrations)) {
-                if (!firstPartyNames.has(name) && providerConfig) {
-                    const pluginId = providerConfig.plugin || name;
-                    const plugin = await loadPlugin(pluginId);
-                    if (!plugin) {
-                        continue;
-                    }
-                    try {
-                        const provider = plugin.createProvider(providerConfig.options || {}, req.project.path);
-                        if (provider.supportsOnDemandImport) {
-                            const testResult = await testProviderConnection(name, providerConfig, req.project.path);
-                            providers.push({
-                                name,
-                                displayName: plugin.displayName,
-                                supportsOnDemandImport: true,
-                                supportsSearch: provider.supportsSearch,
-                                urlPatterns: getProviderUrlPatterns(provider),
-                                configured: testResult.configured,
-                                authMethod: getProviderAuthMethod(name),
-                            });
-                        }
-                    }
-                    catch (error) {
-                        console.warn(`[import] Failed to create custom provider ${name}:`, error);
-                    }
-                }
-            }
-            res.status(200).json({
-                success: true,
-                data: { providers },
-            });
-        }
-        catch (error) {
-            console.error("[import] Failed to list providers:", error);
-            res.status(500).json({
-                success: false,
-                error: "Failed to list import providers",
-                message: error instanceof Error ? error.message : String(error),
-            });
-        }
-    });
-    /**
-     * POST /api/import/preview - Preview an import before creating entity
-     *
-     * Fetches entity from external system and checks if already imported
-     */
-    router.post("/preview", async (req, res) => {
-        try {
-            const { url } = req.body;
-            if (!url || typeof url !== "string") {
-                res.status(400).json({
-                    success: false,
-                    error: "URL is required",
-                    message: "Request body must include a valid URL string",
-                });
-                return;
-            }
-            // Get all enabled providers
-            const config = readConfig(req.project.sudocodeDir);
-            const integrations = (config.integrations || {});
-            const firstPartyPlugins = getFirstPartyPlugins();
-            // Find provider that can handle this URL
-            let matchedProvider = null;
-            let matchedProviderName = null;
-            // Check first-party plugins
-            for (const p of firstPartyPlugins) {
-                const plugin = await loadPlugin(p.name);
-                if (!plugin)
-                    continue;
-                const providerConfig = integrations[p.name];
-                const provider = plugin.createProvider(providerConfig?.options || {}, req.project.path);
-                if (isOnDemandCapable(provider) && provider.canHandleUrl?.(url)) {
-                    matchedProvider = provider;
-                    matchedProviderName = p.name;
-                    break;
-                }
-            }
-            // Check custom providers if no match
-            if (!matchedProvider) {
-                const firstPartyNames = new Set(firstPartyPlugins.map((p) => p.name));
-                for (const [name, providerConfig] of Object.entries(integrations)) {
-                    if (!firstPartyNames.has(name) && providerConfig) {
-                        const pluginId = providerConfig.plugin || name;
-                        const plugin = await loadPlugin(pluginId);
-                        if (!plugin)
-                            continue;
-                        const provider = plugin.createProvider(providerConfig.options || {}, req.project.path);
-                        if (isOnDemandCapable(provider) && provider.canHandleUrl?.(url)) {
-                            matchedProvider = provider;
-                            matchedProviderName = name;
-                            break;
-                        }
-                    }
-                }
-            }
-            if (!matchedProvider || !matchedProviderName) {
-                res.status(422).json({
-                    success: false,
-                    error: "No provider found",
-                    message: `No configured provider can handle URL: ${url}`,
-                });
-                return;
-            }
-            // Initialize provider if needed
-            await matchedProvider.initialize();
-            // Fetch entity by URL
-            const entity = isOnDemandCapable(matchedProvider)
-                ? await matchedProvider.fetchByUrl?.(url)
-                : null;
-            if (!entity) {
-                res.status(404).json({
-                    success: false,
-                    error: "Entity not found",
-                    message: `Could not fetch entity from URL: ${url}`,
-                });
-                return;
-            }
-            // Check if already imported
-            let alreadyLinked;
-            const existingSpecs = findSpecsByExternalLink(req.project.sudocodeDir, matchedProviderName, entity.id);
-            if (existingSpecs.length > 0) {
-                const existingSpec = existingSpecs[0];
-                const link = existingSpec.external_links?.find((l) => l.provider === matchedProviderName && l.external_id === entity.id);
-                alreadyLinked = {
-                    entityId: existingSpec.id,
-                    entityType: "spec",
-                    lastSyncedAt: link?.last_synced_at,
-                };
-            }
-            else {
-                // Also check issues
-                const existingIssues = findIssuesByExternalLink(req.project.sudocodeDir, matchedProviderName, entity.id);
-                if (existingIssues.length > 0) {
-                    const existingIssue = existingIssues[0];
-                    const link = existingIssue.external_links?.find((l) => l.provider === matchedProviderName && l.external_id === entity.id);
-                    alreadyLinked = {
-                        entityId: existingIssue.id,
-                        entityType: "issue",
-                        lastSyncedAt: link?.last_synced_at,
-                    };
-                }
-            }
-            // Fetch comments count if supported
-            let commentsCount;
-            if (isOnDemandCapable(matchedProvider) && matchedProvider.fetchComments) {
-                try {
-                    const comments = await matchedProvider.fetchComments(entity.id);
-                    commentsCount = comments.length;
-                }
-                catch {
-                    // Ignore errors fetching comments for preview
-                }
-            }
-            // Clean up provider
-            await matchedProvider.dispose();
-            const response = {
-                provider: matchedProviderName,
-                entity,
-                commentsCount,
-                alreadyLinked,
-            };
-            res.status(200).json({
-                success: true,
-                data: response,
-            });
-        }
-        catch (error) {
-            console.error("[import] Preview failed:", error);
-            // Handle specific error types
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (errorMessage.includes("not authenticated") ||
-                errorMessage.includes("auth")) {
-                res.status(401).json({
-                    success: false,
-                    error: "Authentication required",
-                    message: errorMessage,
-                });
-                return;
-            }
-            res.status(500).json({
-                success: false,
-                error: "Preview failed",
-                message: errorMessage,
-            });
-        }
-    });
-    /**
-     * POST /api/import/search - Search for entities in external systems
-     *
-     * Searches a provider for entities matching a query, or lists issues from a repo
-     */
-    router.post("/search", async (req, res) => {
-        try {
-            const { provider: providerName, query, repo, page = 1, perPage = 20, } = req.body;
-            if (!providerName || typeof providerName !== "string") {
-                res.status(400).json({
-                    success: false,
-                    error: "Provider is required",
-                    message: "Request body must include a valid provider name",
-                });
-                return;
-            }
-            // Either query or repo must be provided
-            if (!query && !repo) {
-                res.status(400).json({
-                    success: false,
-                    error: "Query or repo is required",
-                    message: "Request body must include a search query or repo to list issues from",
-                });
-                return;
-            }
-            // Get config
-            const config = readConfig(req.project.sudocodeDir);
-            const integrations = (config.integrations || {});
-            // Try to load the provider
-            const plugin = await loadPlugin(providerName);
-            if (!plugin) {
-                res.status(404).json({
-                    success: false,
-                    error: "Provider not found",
-                    message: `Provider "${providerName}" is not installed`,
-                });
-                return;
-            }
-            const providerConfig = integrations[providerName];
-            const provider = plugin.createProvider(providerConfig?.options || {}, req.project.path);
-            // Check if provider supports search
-            if (!provider.supportsSearch) {
-                res.status(422).json({
-                    success: false,
-                    error: "Search not supported",
-                    message: `Provider "${providerName}" does not support search`,
-                });
-                return;
-            }
-            // Initialize provider
-            await provider.initialize();
-            // Search for entities with options
-            const searchResult = await provider.searchEntities(query, {
-                repo,
-                page,
-                perPage: Math.min(perPage, 100),
-            });
-            // Clean up provider
-            await provider.dispose();
-            // Handle both old array format and new SearchResult format
-            const isSearchResult = searchResult &&
-                typeof searchResult === "object" &&
-                "results" in searchResult;
-            const results = isSearchResult
-                ? searchResult.results
-                : searchResult;
-            const pagination = isSearchResult
-                ? searchResult
-                    .pagination
-                : undefined;
-            const response = {
-                provider: providerName,
-                query,
-                repo,
-                results,
-                pagination,
-            };
-            res.status(200).json({
-                success: true,
-                data: response,
-            });
-        }
-        catch (error) {
-            console.error("[import] Search failed:", error);
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (errorMessage.includes("not authenticated") ||
-                errorMessage.includes("auth")) {
-                res.status(401).json({
-                    success: false,
-                    error: "Authentication required",
-                    message: errorMessage,
-                });
-                return;
-            }
-            res.status(500).json({
-                success: false,
-                error: "Search failed",
-                message: errorMessage,
-            });
-        }
-    });
-    /**
-     * POST /api/import/batch - Batch import entities with upsert behavior
-     *
-     * Creates or updates specs from external entities. If an entity is already
-     * imported, it updates the existing spec instead of creating a duplicate.
-     */
-    router.post("/batch", async (req, res) => {
-        try {
-            const { provider: providerName, externalIds, options = {}, } = req.body;
-            // Validation
-            if (!providerName || typeof providerName !== "string") {
-                res.status(400).json({
-                    success: false,
-                    error: "Provider is required",
-                    message: "Request body must include a valid provider name",
-                });
-                return;
-            }
-            if (!Array.isArray(externalIds) || externalIds.length === 0) {
-                res.status(400).json({
-                    success: false,
-                    error: "External IDs required",
-                    message: "Request body must include a non-empty array of external IDs",
-                });
-                return;
-            }
-            // Get config
-            const config = readConfig(req.project.sudocodeDir);
-            const integrations = (config.integrations || {});
-            // Load the provider
-            const plugin = await loadPlugin(providerName);
-            if (!plugin) {
-                res.status(404).json({
-                    success: false,
-                    error: "Provider not found",
-                    message: `Provider "${providerName}" is not installed`,
-                });
-                return;
-            }
-            const providerConfig = integrations[providerName];
-            const provider = plugin.createProvider(providerConfig?.options || {}, req.project.path);
-            // Check capabilities
-            if (!isOnDemandCapable(provider)) {
-                res.status(422).json({
-                    success: false,
-                    error: "Import not supported",
-                    message: `Provider "${providerName}" does not support on-demand import`,
-                });
-                return;
-            }
-            // Initialize provider
-            await provider.initialize();
-            const results = [];
-            let created = 0;
-            let updated = 0;
-            let failed = 0;
-            // Process each external ID
-            for (const externalId of externalIds) {
-                try {
-                    // Fetch the entity
-                    const entity = await provider.fetchEntity(externalId);
-                    if (!entity) {
-                        results.push({
-                            externalId,
-                            success: false,
-                            action: "failed",
-                            error: "Entity not found",
-                        });
-                        failed++;
-                        continue;
-                    }
-                    // Check if already imported
-                    const existingSpecs = findSpecsByExternalLink(req.project.sudocodeDir, providerName, entity.id);
-                    const now = new Date().toISOString();
-                    if (existingSpecs.length > 0) {
-                        // Update existing spec
-                        const existingSpec = existingSpecs[0];
-                        // Import updateSpec from CLI
-                        const { updateSpec } = await import("@sudocode-ai/cli/dist/operations/specs.js");
-                        const { updateSpecExternalLinkSync } = await import("@sudocode-ai/cli/dist/operations/external-links.js");
-                        // Update the spec content
-                        updateSpec(req.project.db, existingSpec.id, {
-                            title: entity.title,
-                            content: entity.description || "",
-                            priority: options.priority ?? entity.priority ?? existingSpec.priority,
-                        });
-                        // Update the external link sync timestamp
-                        updateSpecExternalLinkSync(req.project.sudocodeDir, existingSpec.id, entity.id, {
-                            last_synced_at: now,
-                            external_updated_at: entity.updated_at,
-                        });
-                        // Broadcast update
-                        broadcastSpecUpdate(req.project.id, existingSpec.id, "updated", {
-                            ...existingSpec,
-                            title: entity.title,
-                            content: entity.description || "",
-                        });
-                        results.push({
-                            externalId,
-                            success: true,
-                            entityId: existingSpec.id,
-                            action: "updated",
-                        });
-                        updated++;
-                    }
-                    else {
-                        // Create new spec
-                        const spec = createSpecFromExternal(req.project.sudocodeDir, {
-                            title: entity.title,
-                            content: entity.description || "",
-                            priority: options.priority ?? entity.priority ?? 2,
-                            external: {
-                                provider: providerName,
-                                external_id: entity.id,
-                                sync_direction: "inbound",
-                            },
-                            relationships: entity.relationships?.map((r) => ({
-                                targetExternalId: r.targetId,
-                                targetType: r.targetType,
-                                relationshipType: r.relationshipType,
-                            })),
-                        });
-                        // Broadcast creation
-                        broadcastSpecUpdate(req.project.id, spec.id, "created", spec);
-                        results.push({
-                            externalId,
-                            success: true,
-                            entityId: spec.id,
-                            action: "created",
-                        });
-                        created++;
-                    }
-                }
-                catch (itemError) {
-                    const errorMessage = itemError instanceof Error ? itemError.message : String(itemError);
-                    results.push({
-                        externalId,
-                        success: false,
-                        action: "failed",
-                        error: errorMessage,
-                    });
-                    failed++;
-                }
-            }
-            // Clean up provider
-            await provider.dispose();
-            // Trigger export if any changes were made
-            if (created > 0 || updated > 0) {
-                triggerExport(req.project.db, req.project.sudocodeDir);
-            }
-            const response = {
-                provider: providerName,
-                created,
-                updated,
-                failed,
-                results,
-            };
-            res.status(200).json({
-                success: true,
-                data: response,
-            });
-        }
-        catch (error) {
-            console.error("[import] Batch import failed:", error);
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (errorMessage.includes("not authenticated") ||
-                errorMessage.includes("auth")) {
-                res.status(401).json({
-                    success: false,
-                    error: "Authentication required",
-                    message: errorMessage,
-                });
-                return;
-            }
-            res.status(500).json({
-                success: false,
-                error: "Batch import failed",
-                message: errorMessage,
-            });
-        }
-    });
-    /**
-     * POST /api/import - Import entity and create spec
-     *
-     * Creates a spec with external_link from the given URL
-     */
-    router.post("/", async (req, res) => {
-        try {
-            const { url, options = {} } = req.body;
-            if (!url || typeof url !== "string") {
-                res.status(400).json({
-                    success: false,
-                    error: "URL is required",
-                    message: "Request body must include a valid URL string",
-                });
-                return;
-            }
-            // Get all enabled providers
-            const config = readConfig(req.project.sudocodeDir);
-            const integrations = (config.integrations || {});
-            const firstPartyPlugins = getFirstPartyPlugins();
-            // Find provider that can handle this URL
-            let matchedProvider = null;
-            let matchedProviderName = null;
-            // Check first-party plugins
-            for (const p of firstPartyPlugins) {
-                const plugin = await loadPlugin(p.name);
-                if (!plugin)
-                    continue;
-                const providerConfig = integrations[p.name];
-                const provider = plugin.createProvider(providerConfig?.options || {}, req.project.path);
-                if (isOnDemandCapable(provider) && provider.canHandleUrl?.(url)) {
-                    matchedProvider = provider;
-                    matchedProviderName = p.name;
-                    break;
-                }
-            }
-            // Check custom providers if no match
-            if (!matchedProvider) {
-                const firstPartyNames = new Set(firstPartyPlugins.map((p) => p.name));
-                for (const [name, providerConfig] of Object.entries(integrations)) {
-                    if (!firstPartyNames.has(name) && providerConfig) {
-                        const pluginId = providerConfig.plugin || name;
-                        const plugin = await loadPlugin(pluginId);
-                        if (!plugin)
-                            continue;
-                        const provider = plugin.createProvider(providerConfig.options || {}, req.project.path);
-                        if (isOnDemandCapable(provider) && provider.canHandleUrl?.(url)) {
-                            matchedProvider = provider;
-                            matchedProviderName = name;
-                            break;
-                        }
-                    }
-                }
-            }
-            if (!matchedProvider || !matchedProviderName) {
-                res.status(422).json({
-                    success: false,
-                    error: "No provider found",
-                    message: `No configured provider can handle URL: ${url}`,
-                });
-                return;
-            }
-            // Initialize provider
-            await matchedProvider.initialize();
-            // Fetch entity by URL
-            const entity = isOnDemandCapable(matchedProvider)
-                ? await matchedProvider.fetchByUrl?.(url)
-                : null;
-            if (!entity) {
-                res.status(404).json({
-                    success: false,
-                    error: "Entity not found",
-                    message: `Could not fetch entity from URL: ${url}`,
-                });
-                return;
-            }
-            // Check if already imported
-            const existingSpecs = findSpecsByExternalLink(req.project.sudocodeDir, matchedProviderName, entity.id);
-            if (existingSpecs.length > 0) {
-                res.status(409).json({
-                    success: false,
-                    error: "Already imported",
-                    message: `Entity already imported as spec: ${existingSpecs[0].id}`,
-                    data: {
-                        entityId: existingSpecs[0].id,
-                        entityType: "spec",
-                    },
-                });
-                return;
-            }
-            // Compute content hash
-            const contentHash = computeContentHash(entity.title, entity.description || "");
-            const now = new Date().toISOString();
-            // Create spec with external link
-            const spec = createSpecFromExternal(req.project.sudocodeDir, {
-                title: entity.title,
-                content: entity.description || "",
-                priority: options.priority ?? entity.priority ?? 2,
-                external: {
-                    provider: matchedProviderName,
-                    external_id: entity.id,
-                    sync_direction: "inbound",
-                },
-                relationships: entity.relationships?.map((r) => ({
-                    targetExternalId: r.targetId,
-                    targetType: r.targetType,
-                    relationshipType: r.relationshipType,
-                })),
-            });
-            // Update external_link with additional metadata
-            // Note: This is stored in JSONL, so we need to update there
-            const externalLink = {
-                provider: matchedProviderName,
-                external_id: entity.id,
-                external_url: entity.url,
-                sync_enabled: true,
-                sync_direction: "inbound",
-                last_synced_at: now,
-                external_updated_at: entity.updated_at,
-                content_hash: contentHash,
-                imported_at: now,
-                import_metadata: {
-                    imported_by: "api",
-                    original_status: entity.status,
-                    original_type: entity.type,
-                },
-            };
-            // Trigger export to JSONL files
-            triggerExport(req.project.db, req.project.sudocodeDir);
-            // Sync to markdown file (fire and forget)
-            const syncPromise = syncEntityToMarkdown(req.project.db, spec.id, "spec", req.project.sudocodeDir);
-            if (syncPromise && typeof syncPromise.catch === "function") {
-                syncPromise.catch((error) => {
-                    console.error(`[import] Failed to sync spec ${spec.id} to markdown:`, error);
-                });
-            }
-            // Import comments as IssueFeedback
-            let feedbackCount = 0;
-            if (options.includeComments &&
-                isOnDemandCapable(matchedProvider) &&
-                matchedProvider.fetchComments) {
-                try {
-                    const comments = await matchedProvider.fetchComments(entity.id);
-                    if (comments.length > 0) {
-                        // Create a placeholder issue to serve as the feedback source
-                        // TODO: Support feedback without an issue.
-                        const { id: placeholderIssueId, uuid: placeholderIssueUuid } = generateIssueId(req.project.db, req.project.sudocodeDir);
-                        const placeholderIssue = createIssue(req.project.db, {
-                            id: placeholderIssueId,
-                            uuid: placeholderIssueUuid,
-                            title: `Imported comments for: ${entity.title}`,
-                            content: `This issue was created to hold imported comments from [${entity.url}](${entity.url}).\n\n` +
-                                `Provider: ${matchedProviderName}\n` +
-                                `External ID: ${entity.id}\n` +
-                                `Imported at: ${now}\n` +
-                                `Comments: ${comments.length}`,
-                            status: "closed",
-                            priority: 4, // Lowest priority - placeholder only
-                        });
-                        console.log(`[import] Created placeholder issue ${placeholderIssue.id} for ${comments.length} comments`);
-                        // Import each comment as IssueFeedback
-                        for (const comment of comments) {
-                            try {
-                                createFeedback(req.project.db, {
-                                    from_id: placeholderIssue.id,
-                                    to_id: spec.id,
-                                    feedback_type: "comment",
-                                    content: formatImportedComment(comment),
-                                    agent: "import",
-                                    created_at: comment.created_at,
-                                });
-                                feedbackCount++;
-                            }
-                            catch (feedbackError) {
-                                console.warn(`[import] Failed to create feedback for comment ${comment.id}:`, feedbackError);
-                            }
-                        }
-                        console.log(`[import] Successfully imported ${feedbackCount} of ${comments.length} comments as feedback`);
-                    }
-                }
-                catch (error) {
-                    console.warn("[import] Failed to fetch/import comments:", error);
-                }
-            }
-            // Clean up provider
-            await matchedProvider.dispose();
-            // Broadcast spec creation
-            broadcastSpecUpdate(req.project.id, spec.id, "created", spec);
-            const response = {
-                entityId: spec.id,
-                entityType: "spec",
-                externalLink,
-                feedbackCount: feedbackCount > 0 ? feedbackCount : undefined,
-            };
-            res.status(201).json({
-                success: true,
-                data: response,
-            });
-        }
-        catch (error) {
-            console.error("[import] Import failed:", error);
-            // Handle specific error types
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (errorMessage.includes("not authenticated") ||
-                errorMessage.includes("auth")) {
-                res.status(401).json({
-                    success: false,
-                    error: "Authentication required",
-                    message: errorMessage,
-                });
-                return;
-            }
-            res.status(500).json({
-                success: false,
-                error: "Import failed",
-                message: errorMessage,
-            });
-        }
-    });
-    /**
-     * POST /api/import/refresh - Refresh multiple entities from external sources
-     *
-     * Request body:
-     * - provider?: string - Filter by provider name
-     * - entityIds?: string[] - Specific entity IDs to refresh
-     * - force?: boolean - Skip conflict check, overwrite local changes
-     *
-     * Response:
-     * - refreshed: number - Count of successfully refreshed entities
-     * - skipped: number - Count of skipped entities (no changes or local changes without force)
-     * - failed: number - Count of failed refreshes
-     * - stale: number - Count of stale links (external entity deleted)
-     * - results: Array<{entityId, status, error?}> - Per-entity results
-     */
-    router.post("/refresh", async (req, res) => {
-        try {
-            const { provider, entityIds, force } = req.body;
-            // Validate entityIds if provided
-            if (entityIds !== undefined) {
-                if (!Array.isArray(entityIds)) {
-                    res.status(400).json({
-                        success: false,
-                        error: "Invalid request",
-                        message: "entityIds must be an array of strings",
-                    });
-                    return;
-                }
-                if (!entityIds.every((id) => typeof id === "string")) {
-                    res.status(400).json({
-                        success: false,
-                        error: "Invalid request",
-                        message: "entityIds must contain only strings",
-                    });
-                    return;
-                }
-            }
-            // Validate provider if provided
-            if (provider !== undefined && typeof provider !== "string") {
-                res.status(400).json({
-                    success: false,
-                    error: "Invalid request",
-                    message: "provider must be a string",
-                });
-                return;
-            }
-            // Execute bulk refresh
-            const result = await bulkRefresh(req.project.db, req.project.sudocodeDir, req.project.path, {
-                provider,
-                entityIds,
-                force: force === true,
-            });
-            // Trigger export if any entities were updated
-            if (result.refreshed > 0) {
-                triggerExport(req.project.db, req.project.sudocodeDir);
-            }
-            res.status(200).json({
-                success: true,
-                data: result,
-            });
-        }
-        catch (error) {
-            console.error("[import] Bulk refresh failed:", error);
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            res.status(500).json({
-                success: false,
-                error: "Bulk refresh failed",
-                message: errorMessage,
-            });
-        }
-    });
-    return router;
-}
-//# sourceMappingURL=import.js.map