@dataparade/cli 0.0.1

package/dist/src/core/pipeline/scan-pipeline.js

@@ -0,0 +1,364 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runScanPipeline = runScanPipeline;
+const path_1 = __importDefault(require("path"));
+const ai_orchestrator_options_1 = require("./ai-orchestrator-options");
+const scan_result_schema_1 = require("../schema/scan-result.schema");
+const structural_scan_1 = require("./structural-scan");
+const classifier_phase_1 = require("./classifier-phase");
+const dataflow_phase_1 = require("./dataflow-phase");
+const sorting_1 = require("./sorting");
+const pipeline_1 = require("../../ai-enrichment/pipeline");
+const fallbacks_1 = require("../../ai-enrichment/fallbacks");
+const drop_cross_section_flows_1 = require("../../data-flow/drop-cross-section-flows");
+const agent_orchestrator_1 = require("../../ai-enrichment/agent-orchestrator");
+const third_party_data_flow_1 = require("../../ai-enrichment/third-party-data-flow");
+const third_party_subtype_1 = require("../../ai-enrichment/third-party-subtype");
+const langsmith_tracing_1 = require("../../tracing/langsmith-tracing");
+const stable_component_ids_1 = require("./stable-component-ids");
+const terraform_minimal_services_1 = require("./terraform-minimal-services");
+function emitProgress(onProgress, phase, progress, totalFiles, message) {
+    if (!onProgress)
+        return;
+    const clamped = Math.max(0, Math.min(progress, 1));
+    onProgress({
+        phase,
+        filesProcessed: totalFiles,
+        totalFiles,
+        progress: clamped,
+        message,
+    });
+}
+function buildAiProposalDetails(input) {
+    const appliedSet = new Set(input.appliedProposalIds);
+    const rejectedById = new Map(input.rejectedProposalIds.map((item) => [item.proposalId, item.reason]));
+    const beforeById = new Map(input.componentsBeforeAi.map((component) => [component.id, component]));
+    return input.proposals.map(({ id, proposal }) => {
+        const rejectionReason = rejectedById.get(id);
+        const status = appliedSet.has(id) ? "applied" : "rejected";
+        const propertyChanges = proposal.kind === "component_patch" && status === "applied"
+            ? Object.entries(proposal.setProperties).map(([key, to]) => ({
+                key,
+                from: beforeById.get(proposal.targetComponentId)?.properties?.[key],
+                to,
+            }))
+            : undefined;
+        return {
+            id,
+            source: id.startsWith("heuristic_") ? "heuristic" : "provider",
+            status,
+            rejectionReason: status === "rejected" ? rejectionReason : undefined,
+            kind: proposal.kind,
+            candidateType: proposal.candidateType,
+            agent: proposal.agent,
+            provider: proposal.provider,
+            model: proposal.model,
+            confidence: proposal.confidence.score,
+            confidenceBand: proposal.confidence.band,
+            targetComponentId: proposal.kind === "component_patch" ? proposal.targetComponentId : undefined,
+            targetFlowId: proposal.kind === "flow_patch" ? proposal.targetFlowId : undefined,
+            sourceComponentId: proposal.kind === "flow_patch" ? proposal.sourceComponentId : undefined,
+            targetFlowComponentId: proposal.kind === "flow_patch" ? proposal.targetComponentId : undefined,
+            evidence: proposal.evidence,
+            propertyChanges,
+        };
+    });
+}
+function countRejectionsByReason(rejected, proposalById) {
+    const counts = new Map();
+    for (const item of rejected) {
+        const source = proposalById.get(item.proposalId)?.id.startsWith("provider_")
+            ? "provider"
+            : "heuristic";
+        const key = `${source}:${item.reason}`;
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return counts;
+}
+function isSparse(value) {
+    if (value === null || value === undefined)
+        return true;
+    if (typeof value === "string")
+        return value.trim().length === 0;
+    if (Array.isArray(value))
+        return value.length === 0;
+    return false;
+}
+function incrementCounter(map, key) {
+    map[key] = (map[key] ?? 0) + 1;
+}
+function buildThirdPartyCoverage(input) {
+    const autofilled = {};
+    const suggested = {};
+    const unknown = {};
+    const applied = new Set(input.appliedProposalIds);
+    const rejectedReasonById = new Map(input.rejectedProposalIds.map((entry) => [entry.proposalId, entry.reason]));
+    for (const proposalEntry of input.proposals) {
+        const proposal = proposalEntry.proposal;
+        if (proposal.kind !== "component_patch")
+            continue;
+        if (proposal.candidateType !== "third_party")
+            continue;
+        const keys = Object.keys(proposal.setProperties ?? {});
+        if (keys.length === 0)
+            continue;
+        if (applied.has(proposalEntry.id)) {
+            for (const key of keys)
+                incrementCounter(autofilled, key);
+            continue;
+        }
+        const reason = rejectedReasonById.get(proposalEntry.id) ?? "";
+        if (reason.startsWith("confidence_below_threshold")) {
+            for (const key of keys)
+                incrementCounter(suggested, key);
+        }
+    }
+    for (const component of input.componentsAfterAi) {
+        if (component.type !== "third_party")
+            continue;
+        for (const [key, value] of Object.entries(component.properties ?? {})) {
+            if (isSparse(value))
+                incrementCounter(unknown, key);
+        }
+    }
+    return { autofilled, suggested, unknown };
+}
+/**
+ * Internal scan implementation (ingest → classify → flows → optional AI → validate).
+ */
+async function runScanPipeline(rootPath, config, onProgress) {
+    const start = Date.now();
+    const warnings = [];
+    const errors = [];
+    const projectNameFromPath = path_1.default.basename(rootPath.toString());
+    emitProgress(onProgress, "ingest", 0.05, 0, `Ingesting files from ${rootPath}...`);
+    emitProgress(onProgress, "analyze", 0.25, 0, "Running structural scan...");
+    const structural = await (0, structural_scan_1.runStructuralScanPhase)(rootPath, config, (warning) => warnings.push(warning));
+    const { files, findings, sections, monorepoPackageSectionPathDepth, filesScanned, totalLines, languageStats, terraformScanSummary, } = structural;
+    emitProgress(onProgress, "classify", 0.5, filesScanned, "Classifying detected components...");
+    const components = (0, classifier_phase_1.runClassifierPhase)(findings, sections, {
+        projectName: config.projectName ?? projectNameFromPath,
+        minimumConfidence: config.minimumConfidence,
+    });
+    const subTypesFilledEarly = (0, third_party_subtype_1.ensureThirdPartySubTypes)(components);
+    if (subTypesFilledEarly > 0) {
+        warnings.push(`third-party-subtype: inferred subType for ${subTypesFilledEarly} third-party component(s) from vendor/name heuristics.`);
+    }
+    let dataFlows = [];
+    if (config.enableDataFlowDetection) {
+        emitProgress(onProgress, "data_flow", 0.7, filesScanned, "Detecting data flows...");
+        try {
+            dataFlows = (0, dataflow_phase_1.runDataFlowPhase)(files, components, findings, sections, {
+                enableDataFlowDetection: config.enableDataFlowDetection,
+                minimumConfidence: config.minimumConfidence,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error
+                ? err.message
+                : "Unknown error during data-flow detection.";
+            errors.push(`data-flow: ${message}`);
+            dataFlows = [];
+        }
+    }
+    (0, sorting_1.sortComponentsDeterministically)(components);
+    (0, sorting_1.sortDataFlowsDeterministically)(dataFlows);
+    let aiInferenceSummary;
+    let structuralEnrichmentSummary;
+    let aiInferenceProposalDetails;
+    let inference;
+    let postAiComponents;
+    const plannerInputBase = {
+        components,
+        dataFlows,
+        sections,
+        files,
+        findings,
+        inferenceScope: config.aiInferenceScope ?? "default",
+        plannerOptions: {
+            maxModelCalls: config.aiMaxModelCalls,
+            totalBudgetTokens: config.aiBudgetTokens,
+            maxCandidatesPerAgent: (config.aiInferenceScope ?? "default") === "third_party_only"
+                ? (config.aiMaxCandidatesPerAgent ?? 0)
+                : config.aiMaxCandidatesPerAgent,
+        },
+    };
+    emitProgress(onProgress, "data_flow", 0.82, filesScanned, "Running structural enrichment...");
+    const structuralInference = await (0, pipeline_1.runInferencePipeline)(plannerInputBase, {
+        generateProposals: async (ctx) => (0, agent_orchestrator_1.generateAgenticProposals)({
+            components: ctx.components,
+            dataFlows: ctx.dataFlows,
+            sections: ctx.sections,
+            files: ctx.files,
+            findings: ctx.findings,
+        }, ctx.plan, ctx.candidates, (0, ai_orchestrator_options_1.buildAgentOrchestratorOptions)(config, {
+            llmEnabled: false,
+            skipStructuralHeuristics: false,
+        })),
+    });
+    components.splice(0, components.length, ...structuralInference.mergeResult.components);
+    dataFlows.splice(0, dataFlows.length, ...structuralInference.mergeResult.dataFlows);
+    structuralEnrichmentSummary = {
+        ran: true,
+        proposalsGenerated: structuralInference.proposals.length,
+        proposalsApplied: structuralInference.mergeResult.appliedProposalIds.length,
+        proposalsRejected: structuralInference.mergeResult.rejectedProposalIds.length,
+    };
+    if (config.enableAiInference) {
+        warnings.push("ai-inference: .env files are excluded from scans and provider prompts for security.");
+        const componentsBeforeAi = components.map((component) => ({
+            ...component,
+            properties: { ...component.properties },
+        }));
+        emitProgress(onProgress, "data_flow", 0.85, filesScanned, "Running LLM inference...");
+        const orchOptions = (0, ai_orchestrator_options_1.buildAgentOrchestratorOptions)(config, {
+            llmEnabled: true,
+            skipStructuralHeuristics: true,
+        });
+        inference = await (0, langsmith_tracing_1.traceDataparadeAiInference)({
+            provider: orchOptions.provider,
+            model: orchOptions.model,
+            run: () => (0, pipeline_1.runInferencePipeline)(plannerInputBase, {
+                generateProposals: async (ctx) => (0, agent_orchestrator_1.generateAgenticProposals)({
+                    components: ctx.components,
+                    dataFlows: ctx.dataFlows,
+                    sections: ctx.sections,
+                    files: ctx.files,
+                    findings: ctx.findings,
+                }, ctx.plan, ctx.candidates, orchOptions),
+            }),
+        });
+        components.splice(0, components.length, ...inference.mergeResult.components);
+        dataFlows.splice(0, dataFlows.length, ...inference.mergeResult.dataFlows);
+        postAiComponents = inference.mergeResult.components.map((component) => ({
+            ...component,
+            properties: { ...component.properties },
+        }));
+        const appliedIds = inference.mergeResult.appliedProposalIds;
+        const genP = inference.proposals.filter((p) => p.id.startsWith("provider_"));
+        const appliedP = appliedIds.filter((id) => id.startsWith("provider_")).length;
+        warnings.push(`ai-inference: applied=${appliedIds.length} (provider=${appliedP}), rejected=${inference.mergeResult.rejectedProposalIds.length}`);
+        const proposalById = new Map(inference.proposals.map((p) => [p.id, p]));
+        const rejectionCounts = countRejectionsByReason(inference.mergeResult.rejectedProposalIds, proposalById);
+        const providerTargetNotFound = rejectionCounts.get("provider:target_not_found") ?? 0;
+        if (providerTargetNotFound > 0) {
+            warnings.push(`ai-provider: ${providerTargetNotFound} provider proposal(s) rejected as target_not_found (likely non-canonical targetComponentId; expected component IDs like cmp_*).`);
+        }
+        const providerEvidencePathMissing = rejectionCounts.get("provider:evidence_path_not_in_scan") ?? 0;
+        if (providerEvidencePathMissing > 0) {
+            warnings.push(`ai-provider: ${providerEvidencePathMissing} provider proposal(s) rejected due to evidence_path_not_in_scan.`);
+        }
+        const providerConfidenceRejected = [...rejectionCounts.entries()]
+            .filter(([k]) => k.startsWith("provider:confidence_below_threshold:"))
+            .reduce((acc, [, n]) => acc + n, 0);
+        if (providerConfidenceRejected > 0) {
+            warnings.push(`ai-provider: ${providerConfidenceRejected} provider proposal(s) rejected by confidence thresholds.`);
+        }
+        if (genP.length === 0) {
+            warnings.push([
+                "ai-provider: zero LLM proposals were accepted after inference.",
+                "Check workspace API key, BYOK credentials, network, and SCAN_AI_MAX_TOKENS for large prompts.",
+                "Set SCAN_AI_DEBUG=true to log provider HTTP status and parse/normalization details.",
+            ].join(" "));
+        }
+        else if (genP.length > 0 && appliedP === 0) {
+            warnings.push("ai-provider: proposals were returned but none passed validation/merge (evidence paths, confidence, or thresholds).");
+        }
+        aiInferenceSummary = {
+            ran: true,
+            candidatesConsidered: inference.candidates.length,
+            proposalsGenerated: inference.proposals.length,
+            proposalsApplied: appliedIds.length,
+            proposalsRejected: inference.mergeResult.rejectedProposalIds.length,
+            proposalsGeneratedHeuristic: 0,
+            proposalsAppliedHeuristic: 0,
+            proposalsGeneratedProvider: genP.length,
+            proposalsAppliedProvider: appliedP,
+            aiProvider: orchOptions.platformProxy ? "dataparade" : orchOptions.provider,
+            aiModel: orchOptions.model,
+            providerCalls: inference.usageSummary?.providerCalls ?? 0,
+            inputTokens: inference.usageSummary?.inputTokens ?? 0,
+            outputTokens: inference.usageSummary?.outputTokens ?? 0,
+            totalTokens: inference.usageSummary?.totalTokens ?? 0,
+            estimatedCostUsd: inference.usageSummary?.estimatedCostUsd,
+            thirdPartyPropertyCoverage: buildThirdPartyCoverage({
+                proposals: inference.proposals,
+                appliedProposalIds: inference.mergeResult.appliedProposalIds,
+                rejectedProposalIds: inference.mergeResult.rejectedProposalIds,
+                componentsAfterAi: inference.mergeResult.components,
+            }),
+            agenticTrace: inference.usageSummary?.agenticTrace,
+        };
+        if (config.aiVerbose) {
+            aiInferenceProposalDetails = buildAiProposalDetails({
+                proposals: inference.proposals,
+                appliedProposalIds: inference.mergeResult.appliedProposalIds,
+                rejectedProposalIds: inference.mergeResult.rejectedProposalIds,
+                componentsBeforeAi,
+            });
+        }
+    }
+    const fallbackResult = (0, fallbacks_1.applyDeterministicInferenceFallbacks)(components, dataFlows);
+    components.splice(0, components.length, ...fallbackResult.components);
+    dataFlows = fallbackResult.dataFlows;
+    const subTypesFilledLate = (0, third_party_subtype_1.ensureThirdPartySubTypes)(components);
+    if (subTypesFilledLate > 0) {
+        warnings.push(`third-party-subtype: filled subType for ${subTypesFilledLate} third-party component(s) after inference.`);
+    }
+    dataFlows = (0, drop_cross_section_flows_1.dropCrossSectionServiceFlows)(components, dataFlows);
+    const scanDurationMs = Date.now() - start;
+    emitProgress(onProgress, "output", 0.95, filesScanned, "Assembling scan result...");
+    const reduced = (0, terraform_minimal_services_1.applyTerraformMinimalServiceScanResult)({
+        components,
+        dataFlows,
+        filesScanned,
+        filesSkipped: 0,
+        totalLines,
+        scanDurationMs,
+        warnings,
+        errors,
+        languageStats: languageStats.length > 0 ? languageStats : undefined,
+        aiInferenceSummary,
+        structuralEnrichmentSummary,
+        aiInferenceProposalDetails,
+        terraformScanSummary,
+    });
+    const stableIds = (0, stable_component_ids_1.assignStableComponentIds)(reduced.components, reduced.dataFlows);
+    if (aiInferenceSummary &&
+        inference &&
+        postAiComponents &&
+        config.aiThirdPartyDataFlowEnabled !== false) {
+        aiInferenceSummary = {
+            ...aiInferenceSummary,
+            thirdPartyDataFlow: (0, third_party_data_flow_1.buildThirdPartyDataFlowSummary)({
+                proposals: inference.proposals,
+                appliedProposalIds: inference.mergeResult.appliedProposalIds,
+                componentsAfterAi: stableIds.components,
+                files,
+                agenticTrace: inference.usageSummary?.agenticTrace,
+                proposalTargetComponentIdRemap: (0, third_party_data_flow_1.buildProposalTargetComponentIdRemap)(postAiComponents, stableIds.components),
+            }),
+        };
+    }
+    const scanResult = {
+        ...reduced,
+        components: stableIds.components,
+        dataFlows: stableIds.dataFlows,
+        aiInferenceSummary,
+        structuralEnrichmentSummary,
+    };
+    const validation = (0, scan_result_schema_1.validateScanResult)(scanResult);
+    if (!validation.ok) {
+        errors.push(...validation.errors);
+        scanResult.errors = errors;
+    }
+    emitProgress(onProgress, "output", 1, filesScanned, "Scan complete.");
+    return {
+        scanResult,
+        files,
+        findings,
+    };
+}

package/dist/src/core/pipeline/sorting.d.ts

@@ -0,0 +1,3 @@
+import type { DetectedComponent, DetectedDataFlow } from "../types";
+export declare function sortComponentsDeterministically(components: DetectedComponent[]): void;
+export declare function sortDataFlowsDeterministically(flows: DetectedDataFlow[]): void;

package/dist/src/core/pipeline/sorting.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortComponentsDeterministically = sortComponentsDeterministically;
+exports.sortDataFlowsDeterministically = sortDataFlowsDeterministically;
+function getSectionId(component) {
+    return typeof component.properties?.section_id === "string" &&
+        component.properties.section_id.trim()
+        ? component.properties.section_id.trim()
+        : "<unsectioned>";
+}
+function sortComponentsDeterministically(components) {
+    components.sort((a, b) => {
+        const sa = getSectionId(a);
+        const sb = getSectionId(b);
+        const sectionCmp = sa.localeCompare(sb);
+        if (sectionCmp !== 0)
+            return sectionCmp;
+        const nameCmp = a.name.localeCompare(b.name);
+        if (nameCmp !== 0)
+            return nameCmp;
+        const typeCmp = a.type.localeCompare(b.type);
+        if (typeCmp !== 0)
+            return typeCmp;
+        const subTypeA = a.subType ?? "";
+        const subTypeB = b.subType ?? "";
+        const subCmp = subTypeA.localeCompare(subTypeB);
+        if (subCmp !== 0)
+            return subCmp;
+        return a.id.localeCompare(b.id);
+    });
+}
+function sortDataFlowsDeterministically(flows) {
+    flows.sort((a, b) => {
+        const typeCmp = a.type.localeCompare(b.type);
+        if (typeCmp !== 0)
+            return typeCmp;
+        const scCmp = a.sourceComponentId.localeCompare(b.sourceComponentId);
+        if (scCmp !== 0)
+            return scCmp;
+        const tcCmp = a.targetComponentId.localeCompare(b.targetComponentId);
+        if (tcCmp !== 0)
+            return tcCmp;
+        const idCmp = a.id.localeCompare(b.id);
+        if (idCmp !== 0)
+            return idCmp;
+        return a.confidence - b.confidence;
+    });
+}

package/dist/src/core/pipeline/stable-component-ids.d.ts

@@ -0,0 +1,15 @@
+import type { DetectedComponent } from "../types/component";
+import type { DetectedDataFlow } from "../types/data-flow";
+/**
+ * Deterministic identity for remapping component ids after Terraform reduction.
+ * Priority: terraform_address → managed service tuple → app surface tuple.
+ */
+export declare function stableComponentKey(component: DetectedComponent): string;
+/**
+ * Reassign `cmp_1` … `cmp_n` from {@link stableComponentKey} ordering and rewrite
+ * flow endpoints plus `managed_by_provider` references.
+ */
+export declare function assignStableComponentIds(components: DetectedComponent[], dataFlows: DetectedDataFlow[]): {
+    components: DetectedComponent[];
+    dataFlows: DetectedDataFlow[];
+};

package/dist/src/core/pipeline/stable-component-ids.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stableComponentKey = stableComponentKey;
+exports.assignStableComponentIds = assignStableComponentIds;
+const sectioning_1 = require("../../classifier/sectioning");
+function normalizeName(name) {
+    return name.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function firstSourceFilePath(component) {
+    const paths = (component.sourceLocations ?? []).map((loc) => loc.filePath.replace(/\\/g, "/"));
+    paths.sort((a, b) => a.localeCompare(b));
+    return paths[0] ?? "";
+}
+/**
+ * Deterministic identity for remapping component ids after Terraform reduction.
+ * Priority: terraform_address → managed service tuple → app surface tuple.
+ */
+function stableComponentKey(component) {
+    const addr = component.properties?.terraform_address;
+    if (typeof addr === "string" && addr.trim()) {
+        return `tf:${addr.trim()}`;
+    }
+    const managedBy = component.properties?.managed_by_provider;
+    const managedKey = component.properties?.managed_service_key;
+    if (typeof managedBy === "string" &&
+        managedBy.trim() &&
+        typeof managedKey === "string" &&
+        managedKey.trim()) {
+        const sid = (0, sectioning_1.getSectionIdFromProperties)(component.properties);
+        return `managed:${managedBy.trim()}|${String(managedKey).trim()}|${sid}`;
+    }
+    const sid = (0, sectioning_1.getSectionIdFromProperties)(component.properties);
+    const subType = component.subType ?? "";
+    const filePath = firstSourceFilePath(component);
+    return `app:${sid}|${component.type}|${subType}|${filePath}|${normalizeName(component.name)}`;
+}
+function compareComponentsForStableIds(a, b) {
+    const keyCmp = stableComponentKey(a).localeCompare(stableComponentKey(b));
+    if (keyCmp !== 0)
+        return keyCmp;
+    return a.id.localeCompare(b.id);
+}
+/**
+ * Reassign `cmp_1` … `cmp_n` from {@link stableComponentKey} ordering and rewrite
+ * flow endpoints plus `managed_by_provider` references.
+ */
+function assignStableComponentIds(components, dataFlows) {
+    const sorted = [...components].sort(compareComponentsForStableIds);
+    const idRemap = new Map();
+    sorted.forEach((component, index) => {
+        idRemap.set(component.id, `cmp_${index + 1}`);
+    });
+    const remappedComponents = components.map((component) => {
+        const newId = idRemap.get(component.id) ?? component.id;
+        const properties = { ...component.properties };
+        const managedBy = properties.managed_by_provider;
+        if (typeof managedBy === "string" && idRemap.has(managedBy)) {
+            properties.managed_by_provider = idRemap.get(managedBy);
+        }
+        return { ...component, id: newId, properties };
+    });
+    const remappedFlows = dataFlows.map((flow) => ({
+        ...flow,
+        sourceComponentId: idRemap.get(flow.sourceComponentId) ?? flow.sourceComponentId,
+        targetComponentId: idRemap.get(flow.targetComponentId) ?? flow.targetComponentId,
+    }));
+    return { components: remappedComponents, dataFlows: remappedFlows };
+}

package/dist/src/core/pipeline/structural-scan.d.ts

@@ -0,0 +1,19 @@
+import type { FileInfo, LanguageParserStats, RawFinding, ScanConfiguration, ScanResult, TerraformScanSummary } from "../types";
+import type { ServiceSection } from "../sectioning/discover-service-sections";
+export interface StructuralScanPhaseResult {
+    files: FileInfo[];
+    findings: RawFinding[];
+    sections: ServiceSection[];
+    monorepoPackageSectionPathDepth?: number;
+    filesScanned: number;
+    totalLines: number;
+    languageStats: LanguageParserStats[];
+    terraformScanSummary?: TerraformScanSummary;
+}
+export interface StructuralScanResult {
+    scanResult: ScanResult;
+    files: FileInfo[];
+    findings: RawFinding[];
+}
+export declare function runStructuralScanPhase(rootPath: string, config: ScanConfiguration, onWarning?: (warning: string) => void): Promise<StructuralScanPhaseResult>;
+export declare function runStructuralScan(rootPath: string): Promise<StructuralScanResult>;