@dataparade/cli 0.0.1

package/dist/src/core/sectioning/section-runtime.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TERRAFORM_DETECTED_FROM_PATTERNS = void 0;
+exports.sectionHasPackageJsonManifest = sectionHasPackageJsonManifest;
+exports.isScaffoldOrTemplatePackageSection = isScaffoldOrTemplatePackageSection;
+exports.sectionHasClassifiedComponents = sectionHasClassifiedComponents;
+exports.isConcreteServiceSectionId = isConcreteServiceSectionId;
+exports.isTerraformDerivedComponent = isTerraformDerivedComponent;
+exports.isTerraformStackSection = isTerraformStackSection;
+exports.sectionHasRuntimeCodeComponents = sectionHasRuntimeCodeComponents;
+exports.sectionQualifiesForSyntheticApplication = sectionQualifiesForSyntheticApplication;
+exports.shouldInjectUserActorForMainApp = shouldInjectUserActorForMainApp;
+const sectioning_1 = require("../../classifier/sectioning");
+const MANIFEST_ONLY_PATH_SUFFIXES = [
+    "package.json",
+    "pyproject.toml",
+    "pipfile",
+    "requirements.txt",
+];
+/** True when this section discovered a `package.json` under `sectionDir`. */
+function sectionHasPackageJsonManifest(section) {
+    return section.manifestPaths.some((p) => p.replace(/\\/g, "/").split("/").pop()?.toLowerCase() === "package.json");
+}
+const GENERATOR_TEMPLATE_DIR_SEGMENTS = new Set([
+    "template",
+    "templates",
+    "scaffold",
+    "boilerplate",
+]);
+function sectionPathHasGeneratorTemplateLayout(sectionDir) {
+    const parts = sectionDir.replace(/\\/g, "/").split("/").filter(Boolean);
+    return parts.some((p) => GENERATOR_TEMPLATE_DIR_SEGMENTS.has(p.toLowerCase()));
+}
+/**
+ * Placeholder `package.json` names are often SHOUTING_CASE with multiple segments
+ */
+function packageNameLooksLikePlaceholderToken(packageName) {
+    const raw = packageName.trim();
+    if (!raw)
+        return false;
+    const base = raw.includes("/") ? (raw.split("/").pop() ?? raw) : raw;
+    const unscoped = base.replace(/^@[^/]+\//, "").replace(/^@/, "");
+    if (/[a-z]/.test(unscoped))
+        return false;
+    if (!/^[A-Z0-9][A-Z0-9_-]*$/.test(unscoped))
+        return false;
+    return unscoped.split(/[-_]/).filter((p) => p.length > 0).length >= 2;
+}
+/** Generator templates / placeholder manifests (not deployable workspace apps). */
+function isScaffoldOrTemplatePackageSection(section) {
+    const dir = section.sectionDir || section.id;
+    if (sectionPathHasGeneratorTemplateLayout(dir))
+        return true;
+    const pkg = section.packageName?.trim() ?? "";
+    return pkg.length > 0 && packageNameLooksLikePlaceholderToken(pkg);
+}
+/** At least one classified component is scoped to this section. */
+function sectionHasClassifiedComponents(components, sectionId) {
+    for (const component of components) {
+        if ((0, sectioning_1.getSectionIdFromProperties)(component.properties) === sectionId) {
+            return true;
+        }
+    }
+    return false;
+}
+function isConcreteServiceSectionId(sectionId) {
+    if (!sectionId?.trim())
+        return false;
+    const id = sectionId.trim();
+    return id !== "root" && id !== "global" && id !== "<unsectioned>";
+}
+var component_predicates_1 = require("../terraform/component-predicates");
+Object.defineProperty(exports, "TERRAFORM_DETECTED_FROM_PATTERNS", { enumerable: true, get: function () { return component_predicates_1.TERRAFORM_DETECTED_FROM_PATTERNS; } });
+const component_predicates_2 = require("../terraform/component-predicates");
+/** Classified from Terraform analysis (HCL or show-json), not application source code. */
+function isTerraformDerivedComponent(component) {
+    if ((0, component_predicates_2.hasTerraformAddress)(component))
+        return true;
+    return (0, component_predicates_2.isTerraformDerivedFromPatterns)(component);
+}
+/** Section created for a Terraform stack root or module directory. */
+function isTerraformStackSection(section) {
+    if (section.isTerraformStack === true)
+        return true;
+    const dir = (section.sectionDir || section.id).replace(/\\/g, "/").toLowerCase();
+    if (!dir || dir === "root")
+        return false;
+    return (dir === "terraform" ||
+        dir.startsWith("terraform/") ||
+        dir.includes("/terraform/") ||
+        dir.endsWith("/terraform"));
+}
+function sectionHasRuntimeCodeComponents(components, sectionId) {
+    for (const component of components) {
+        if ((0, sectioning_1.getSectionIdFromProperties)(component.properties) !== sectionId)
+            continue;
+        if (isTerraformDerivedComponent(component))
+            continue;
+        if (component.subType === "database")
+            return true;
+        if (component.detectedFrom?.some((ref) => ref.pattern === "express_route")) {
+            return true;
+        }
+        const locations = component.sourceLocations ?? [];
+        if (locations.some((loc) => {
+            const fp = loc.filePath.replace(/\\/g, "/").toLowerCase();
+            return !MANIFEST_ONLY_PATH_SUFFIXES.some((suffix) => fp.endsWith(suffix));
+        })) {
+            if (component.type === "asset" || component.type === "actor") {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Whether a workspace section should receive a synthetic application hub and
+ * default User actor (tooling-only packages like cli/docs/utils are skipped).
+ */
+function sectionQualifiesForSyntheticApplication(section, components) {
+    if (section.role !== "service")
+        return false;
+    if (isTerraformStackSection(section))
+        return false;
+    if (isScaffoldOrTemplatePackageSection(section))
+        return false;
+    if (sectionHasRuntimeCodeComponents(components, section.id))
+        return true;
+    if (sectionHasPackageJsonManifest(section) &&
+        sectionHasClassifiedComponents(components, section.id)) {
+        return true;
+    }
+    return false;
+}
+function shouldInjectUserActorForMainApp(mainApp, components) {
+    const sectionId = (0, sectioning_1.getSectionIdFromProperties)(mainApp.properties);
+    if (mainApp.properties?.sourceContext !== "injected_project_placeholder") {
+        return true;
+    }
+    if (!isConcreteServiceSectionId(sectionId))
+        return true;
+    if (isTerraformStackSection({ id: sectionId, sectionDir: sectionId })) {
+        return false;
+    }
+    if (sectionHasRuntimeCodeComponents(components, sectionId))
+        return true;
+    return mainApp.properties?.is_primary_monorepo_package === true;
+}

package/dist/src/core/terraform/component-predicates.d.ts

@@ -0,0 +1,13 @@
+import type { DetectedComponent } from "../types/component";
+export declare const TERRAFORM_DETECTED_FROM_PATTERNS: Set<string>;
+export declare const ROOT_LIKE_SECTION_IDS: Set<string>;
+export declare function trimTerraformAddress(component: DetectedComponent): string;
+export declare function hasTerraformAddress(component: DetectedComponent): boolean;
+export declare function scanHasTerraformAddress(components: DetectedComponent[]): boolean;
+export declare function isTerraformProviderComponent(component: DetectedComponent | undefined): boolean;
+export declare function isRootLikeSectionId(sectionId: string | undefined): boolean;
+/** Non-Terraform detectedFrom patterns or non-`.tf` source paths. */
+export declare function hasNonTerraformAppSource(component: DetectedComponent): boolean;
+/** App surface signals for root-scoped assets (single-package repos). */
+export declare function hasNonTerraformAppSignals(component: DetectedComponent): boolean;
+export declare function isTerraformDerivedFromPatterns(component: DetectedComponent): boolean;

package/dist/src/core/terraform/component-predicates.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROOT_LIKE_SECTION_IDS = exports.TERRAFORM_DETECTED_FROM_PATTERNS = void 0;
+exports.trimTerraformAddress = trimTerraformAddress;
+exports.hasTerraformAddress = hasTerraformAddress;
+exports.scanHasTerraformAddress = scanHasTerraformAddress;
+exports.isTerraformProviderComponent = isTerraformProviderComponent;
+exports.isRootLikeSectionId = isRootLikeSectionId;
+exports.hasNonTerraformAppSource = hasNonTerraformAppSource;
+exports.hasNonTerraformAppSignals = hasNonTerraformAppSignals;
+exports.isTerraformDerivedFromPatterns = isTerraformDerivedFromPatterns;
+const application_injection_1 = require("../../classifier/application-injection");
+exports.TERRAFORM_DETECTED_FROM_PATTERNS = new Set([
+    "terraform_resource",
+    "terraform_module",
+    "terraform_provider",
+]);
+exports.ROOT_LIKE_SECTION_IDS = new Set(["root", "global", "<unsectioned>"]);
+function trimTerraformAddress(component) {
+    const addr = component.properties?.terraform_address;
+    return typeof addr === "string" ? addr.trim() : "";
+}
+function hasTerraformAddress(component) {
+    return trimTerraformAddress(component).length > 0;
+}
+function scanHasTerraformAddress(components) {
+    return components.some(hasTerraformAddress);
+}
+function isTerraformProviderComponent(component) {
+    if (component?.type !== "third_party")
+        return false;
+    const addr = trimTerraformAddress(component);
+    return addr.startsWith("provider.");
+}
+function isRootLikeSectionId(sectionId) {
+    const sid = sectionId?.trim() ?? "";
+    return exports.ROOT_LIKE_SECTION_IDS.has(sid);
+}
+/** Non-Terraform detectedFrom patterns or non-`.tf` source paths. */
+function hasNonTerraformAppSource(component) {
+    if (component.detectedFrom?.some((ref) => !exports.TERRAFORM_DETECTED_FROM_PATTERNS.has(ref.pattern))) {
+        return true;
+    }
+    return (component.sourceLocations?.some((loc) => {
+        const fp = loc.filePath.replace(/\\/g, "/").toLowerCase();
+        return !fp.endsWith(".tf");
+    }) ?? false);
+}
+/** App surface signals for root-scoped assets (single-package repos). */
+function hasNonTerraformAppSignals(component) {
+    const props = component.properties ?? {};
+    const isInjectedPlaceholder = props.sourceContext === application_injection_1.INJECTED_PROJECT_PLACEHOLDER_SOURCE_CONTEXT;
+    if (props.isSectionApiNode === true || props.isSectionApiNode === "true") {
+        return true;
+    }
+    if (hasNonTerraformAppSource(component)) {
+        return true;
+    }
+    if (props.isMainApplication === true || props.isMainApplication === "true") {
+        if (isInjectedPlaceholder)
+            return false;
+        if (component.subType === "api" || component.subType === "service") {
+            return true;
+        }
+        return hasNonTerraformAppSource(component);
+    }
+    return false;
+}
+function isTerraformDerivedFromPatterns(component) {
+    return (component.detectedFrom?.some((ref) => exports.TERRAFORM_DETECTED_FROM_PATTERNS.has(ref.pattern)) ?? false);
+}

package/dist/src/core/types/component.d.ts

@@ -0,0 +1,18 @@
+import type { SourceLocation } from "./file";
+export type ComponentType = "asset" | "actor" | "third_party";
+export interface DetectedFromRef {
+    pattern: string;
+    sourceLocation?: SourceLocation;
+}
+export interface DetectedComponent {
+    id: string;
+    name: string;
+    type: ComponentType;
+    subType?: string;
+    description?: string;
+    confidence: number;
+    detectedFrom: DetectedFromRef[];
+    sourceLocations: SourceLocation[];
+    properties: Record<string, unknown>;
+    dataFlowIds?: string[];
+}

package/dist/src/core/types/component.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/core/types/config.d.ts

@@ -0,0 +1,57 @@
+import type { FileLanguage } from "./file";
+import type { AiInferenceScope, AiProviderId } from "../../ai-enrichment/types";
+export interface ScanConfiguration {
+    projectName?: string;
+    excludePaths?: string[];
+    enableAPIDetection: boolean;
+    enableDatabaseDetection: boolean;
+    enableDataFlowDetection: boolean;
+    languages?: FileLanguage[];
+    minimumConfidence: number;
+    deepAnalysis?: boolean;
+    terraformJsonPath?: string;
+    terraformPlanPath?: string;
+    terraformStackSectionPathDepth?: number;
+    /** When true (default), infer stack section depth from `.tf` layout if depth is unset. */
+    autoInferTerraformStackSectionPathDepth?: boolean;
+    /** Fixed workspace package depth (POSIX segments); overrides inference when set. */
+    monorepoPackageSectionPathDepth?: number;
+    /** When true (default), infer workspace package depth from `package.json` layout. */
+    autoInferMonorepoPackageSectionPathDepth?: boolean;
+    enableAiInference?: boolean;
+    aiProvider?: AiProviderId;
+    aiModel?: string;
+    aiEndpoint?: string;
+    aiApiKey?: string;
+    aiTemperature?: number;
+    aiMaxTokens?: number;
+    aiMaxModelCalls?: number;
+    aiBudgetTokens?: number;
+    /** Max in-flight provider calls for tpAgent (batch size / burst control). */
+    aiProviderConcurrency?: number;
+    /**
+     * Max inference work items queued per agent (property, third-party, etc.).
+     * Use `0` for no cap (every matching node / flow can be queued — costly).
+     */
+    aiMaxCandidatesPerAgent?: number;
+    /** Default: full inference; `third_party_only` runs AI only on every third_party node. */
+    aiInferenceScope?: AiInferenceScope;
+    /** When true, include per-proposal AI inference details in scan output/logs. */
+    aiVerbose?: boolean;
+    /** Max iterative rounds for third-party orchestrator tool loop. */
+    aiToolLoopMaxRounds?: number;
+    /** Max distinct files reviewed per third-party candidate in tool loop. */
+    aiToolLoopMaxFiles?: number;
+    /** Max seeded search terms per third-party candidate in tool loop. */
+    aiToolLoopMaxSearches?: number;
+    /** Toggle third-party data-flow inference summary generation in AI metadata. */
+    aiThirdPartyDataFlowEnabled?: boolean;
+    /** DataParade workspace API key (quota + platform LLM proxy). */
+    workspaceApiKey?: string;
+    /** How LLM inference is billed: byok (direct provider) or platform (API proxy). */
+    aiMode?: "byok" | "platform" | "none";
+    /** Base URL for platform API (preflight / infer / complete). */
+    platformApiBaseUrl?: string;
+    /** CLI quota job id from preflight (platform mode). */
+    cliQuotaJobId?: string;
+}

package/dist/src/core/types/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/core/types/data-flow.d.ts

@@ -0,0 +1,24 @@
+import type { SourceLocation } from "./file";
+export type DataFlowType = "api_call" | "database_query" | "message_queue" | "file_transfer" | "webhook" | "rpc";
+export interface DetectedDataFlow {
+    id: string;
+    sourceComponentId: string;
+    targetComponentId: string;
+    type: DataFlowType;
+    description?: string;
+    confidence: number;
+    sourceLocation?: SourceLocation;
+    sourceLocations?: SourceLocation[];
+    method?: string;
+    endpoint?: string;
+    dataCategories?: string[];
+    dataSubjectCategories?: string[];
+    processingPurpose?: string[];
+    actions?: string[];
+    transformation?: string[];
+    enrichmentConfidence?: number;
+    enrichmentNotes?: string;
+    targetScope?: "local" | "cross_section_internal" | "external" | "unknown";
+    targetScopeConfidence?: "high" | "medium" | "low";
+    targetScopeReason?: string;
+}

package/dist/src/core/types/data-flow.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/core/types/detection.d.ts

@@ -0,0 +1,12 @@
+import type { SourceLocation } from "./file";
+export type PatternId = "express_route" | "database_connection" | "external_api_call" | "auth_middleware" | "config_file" | "env_variable" | "lambda_handler" | "container_service" | "web_actor" | "service_actor" | "terraform_resource" | "terraform_module" | "terraform_provider";
+/** All valid pattern IDs; use for runtime validation (e.g. YAML config). */
+export declare const PATTERN_IDS: readonly PatternId[];
+export interface RawFinding {
+    pattern: PatternId;
+    name: string;
+    description?: string;
+    confidence: number;
+    location: SourceLocation;
+    properties: Record<string, unknown>;
+}

package/dist/src/core/types/detection.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PATTERN_IDS = void 0;
+/** All valid pattern IDs; use for runtime validation (e.g. YAML config). */
+exports.PATTERN_IDS = [
+    "express_route",
+    "database_connection",
+    "external_api_call",
+    "auth_middleware",
+    "config_file",
+    "env_variable",
+    "lambda_handler",
+    "container_service",
+    "web_actor",
+    "service_actor",
+    "terraform_resource",
+    "terraform_module",
+    "terraform_provider",
+];

package/dist/src/core/types/file.d.ts

@@ -0,0 +1,14 @@
+export type FileLanguage = "typescript" | "javascript" | "json" | "yaml" | "env" | "python" | "terraform" | "dockerfile";
+export interface FileInfo {
+    path: string;
+    name: string;
+    content: string;
+    language: FileLanguage;
+    size: number;
+}
+export interface SourceLocation {
+    filePath: string;
+    startLine: number;
+    endLine: number;
+    code?: string;
+}

package/dist/src/core/types/file.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/core/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./file";
+export * from "./detection";
+export * from "./component";
+export * from "./data-flow";
+export * from "./config";
+export * from "./progress";
+export * from "./result";

package/dist/src/core/types/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./file"), exports);
+__exportStar(require("./detection"), exports);
+__exportStar(require("./component"), exports);
+__exportStar(require("./data-flow"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./progress"), exports);
+__exportStar(require("./result"), exports);

package/dist/src/core/types/progress.d.ts

@@ -0,0 +1,9 @@
+export type ScanPhase = "idle" | "ingest" | "analyze" | "classify" | "data_flow" | "ai_enrichment" | "output";
+export interface ScanProgress {
+    phase: ScanPhase;
+    currentFile?: string;
+    filesProcessed: number;
+    totalFiles: number;
+    progress: number;
+    message?: string;
+}

package/dist/src/core/types/progress.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/core/types/result.d.ts

@@ -0,0 +1,140 @@
+import type { DetectedComponent } from "./component";
+import type { DetectedDataFlow } from "./data-flow";
+export interface LanguageParserStats {
+    language: string;
+    filesParsed: number;
+    functionsIndexed: number;
+    moduleLevelCallsIndexed: number;
+    warnings: string[];
+}
+export type ThirdPartyDataDirection = "outbound_to_third_party" | "inbound_from_third_party" | "bidirectional" | "unknown";
+export type ThirdPartyDataCategory = "credentials" | "auth_artifacts" | "identifiers" | "content_files" | "telemetry" | "financial" | "health" | "profile_data" | "usage_metadata" | "unknown";
+export interface ThirdPartyDataFlowEvidenceRef {
+    filePath: string;
+    startLine: number;
+    endLine: number;
+    reason: string;
+}
+export interface ThirdPartyDataFlowElement {
+    category: ThirdPartyDataCategory;
+    labels: string[];
+}
+export interface ThirdPartyDataFlowEntry {
+    componentId: string;
+    componentName: string;
+    service?: string;
+    capabilities: string[];
+    direction: ThirdPartyDataDirection;
+    dataShared: ThirdPartyDataFlowElement[];
+    confidence: number;
+    confidenceBand: "high" | "medium" | "low";
+    source: "provider" | "heuristic" | "provider_plus_heuristic";
+    notes?: string[];
+    evidence: ThirdPartyDataFlowEvidenceRef[];
+}
+export interface ThirdPartyDataFlowSummary {
+    entries: ThirdPartyDataFlowEntry[];
+    totals: {
+        thirdPartiesAnalyzed: number;
+        withDataShared: number;
+    };
+}
+/** Local heuristic enrichment (not counted as platform AI tokens). */
+export interface StructuralEnrichmentSummary {
+    ran: true;
+    proposalsGenerated: number;
+    proposalsApplied: number;
+    proposalsRejected: number;
+}
+/** Populated when LLM inference ran for this scan. */
+export interface AiInferenceSummary {
+    ran: true;
+    /** Candidates passed to the inference planner (before per-agent caps). */
+    candidatesConsidered: number;
+    /** Proposals produced (heuristic agents + provider); merge may reject many. */
+    proposalsGenerated: number;
+    proposalsApplied: number;
+    proposalsRejected: number;
+    /** Built-in rules inside the inference step (often duplicate pattern-detection fields). */
+    proposalsGeneratedHeuristic: number;
+    proposalsAppliedHeuristic: number;
+    /** Cloud model output (`provider_*` ids). */
+    proposalsGeneratedProvider: number;
+    proposalsAppliedProvider: number;
+    providerCalls: number;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    estimatedCostUsd?: number;
+    aiProvider: string;
+    aiModel: string;
+    thirdPartyPropertyCoverage?: {
+        autofilled: Record<string, number>;
+        suggested: Record<string, number>;
+        unknown: Record<string, number>;
+    };
+    thirdPartyDataFlow?: ThirdPartyDataFlowSummary;
+    agenticTrace?: Array<{
+        candidateId: string;
+        componentId?: string;
+        filesReviewed: string[];
+        rounds: number;
+        finalProposalCount: number;
+        toolCalls: Array<{
+            round: number;
+            action: string;
+            detail: string;
+            filesTouched?: string[];
+            stats?: Record<string, number>;
+        }>;
+    }>;
+}
+export interface AiInferenceProposalDetail {
+    id: string;
+    source: "heuristic" | "provider";
+    status: "applied" | "rejected";
+    rejectionReason?: string;
+    kind: "component_patch" | "flow_patch";
+    candidateType: string;
+    agent: string;
+    provider: string;
+    model: string;
+    confidence: number;
+    confidenceBand: "high" | "medium" | "low";
+    targetComponentId?: string;
+    targetFlowId?: string;
+    sourceComponentId?: string;
+    targetFlowComponentId?: string;
+    evidence: Array<{
+        filePath: string;
+        startLine: number;
+        endLine: number;
+        reason: string;
+    }>;
+    propertyChanges?: Array<{
+        key: string;
+        from: unknown;
+        to: unknown;
+    }>;
+}
+export interface TerraformScanSummary {
+    mode: "static_tf" | "json_overlay" | "json_only";
+    staticTfFiles: number;
+    jsonInputPath?: string;
+    jsonFindingsMerged: number;
+}
+export interface ScanResult {
+    components: DetectedComponent[];
+    dataFlows: DetectedDataFlow[];
+    filesScanned: number;
+    filesSkipped: number;
+    totalLines: number;
+    scanDurationMs: number;
+    warnings: string[];
+    errors: string[];
+    languageStats?: LanguageParserStats[];
+    structuralEnrichmentSummary?: StructuralEnrichmentSummary;
+    aiInferenceSummary?: AiInferenceSummary;
+    aiInferenceProposalDetails?: AiInferenceProposalDetail[];
+    terraformScanSummary?: TerraformScanSummary;
+}

package/dist/src/core/types/result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/data-flow/application-hub.d.ts

@@ -0,0 +1,7 @@
+import type { DetectedComponent } from "../core/types/component";
+/**
+ * Resolves the "application hub" used for actor→hub flows and actor→infra
+ * rewiring. Prefers explicit main apps, then api/service assets, then a
+ * Terraform cloud provider node when the scan is infrastructure-only.
+ */
+export declare function findApplicationHubForFlows(components: DetectedComponent[], sectionId?: string): DetectedComponent | undefined;