@dataparade/cli 0.0.1

package/dist/src/core/sectioning/discover-service-sections.d.ts

@@ -0,0 +1,80 @@
+import type { RawFinding } from "../types/detection";
+export interface ServiceSection {
+    /**
+     * Stable identifier used by the CLI import/layout layer.
+     * Stored as `node.data.section_id`.
+     */
+    id: string;
+    /**
+     * Human readable label stored as `node.data.section_label`.
+     */
+    label: string;
+    /**
+     * Role stored as `node.data.section_role`.
+     *
+     * - `root`: fallback scan-root / non-manifest-tagged files
+     * - `service`: directories that contain at least one discovered manifest
+     */
+    role: "root" | "service";
+    /**
+     * Relative directory path (POSIX, relative to scan root) used for matching.
+     * The root/fallback section uses ''.
+     */
+    sectionDir: string;
+    /**
+     * Manifest files discovered under this section directory (relative, POSIX).
+     */
+    manifestPaths: string[];
+    /** npm/pnpm `name` from package.json when this section has one. */
+    packageName?: string;
+    /**
+     * Workspace-level package hub for monorepo rollup (see inferred monorepo depth).
+     * When unset, all `service` sections are treated as primary.
+     */
+    isPrimaryMonorepoPackage?: boolean;
+    /**
+     * Section registered from Terraform config only (no `package.json` under `sectionDir`).
+     * Set at discovery; used by {@link isTerraformStackSection} instead of path heuristics.
+     */
+    isTerraformStack?: boolean;
+}
+export interface DiscoverServiceSectionsOptions {
+    excludePaths?: string[];
+    terraformStackSectionPathDepth?: number;
+    /**
+     * When `terraformStackSectionPathDepth` is omitted, infer `N` from `.tf` layout.
+     * Defaults to true via `createDefaultScanConfiguration`; set false to disable.
+     */
+    autoInferTerraformStackSectionPathDepth?: boolean;
+    /** Override inferred workspace package depth (POSIX segments under scan root). */
+    monorepoPackageSectionPathDepth?: number;
+    /**
+     * When `monorepoPackageSectionPathDepth` is omitted, infer workspace depth from
+     * `package.json` layout. Defaults to true via `createDefaultScanConfiguration`.
+     */
+    autoInferMonorepoPackageSectionPathDepth?: boolean;
+}
+export interface DiscoverServiceSectionsResult {
+    sections: ServiceSection[];
+    /** Set when depth was inferred (not passed explicitly). */
+    inferredTerraformStackSectionPathDepth?: number;
+    inferredMonorepoPackageSectionPathDepth?: number;
+    /** Effective monorepo depth after inference or explicit override. */
+    monorepoPackageSectionPathDepth?: number;
+}
+/**
+ * Pick path depth `N` where the most Terraform stack directories live.
+ * Prefers directories that contain `main.tf`; falls back to any `*.tf` directory.
+ * Tie-break: deeper `N` (more specific stack roots).
+ */
+export declare function inferTerraformStackSectionPathDepth(tfConfigRelPaths: string[]): number | undefined;
+/**
+ * Pick workspace package depth: shallowest path depth with at least two
+ * `package.json` directories (typical `packages/*` monorepo layout).
+ */
+export declare function inferMonorepoPackageSectionPathDepth(packageJsonRelPaths: string[]): number | undefined;
+export declare function rollupSectionIdToMonorepoDepth(sectionId: string, depth: number): string;
+export declare function discoverServiceSections(rootPath: string, opts?: DiscoverServiceSectionsOptions): Promise<DiscoverServiceSectionsResult>;
+export declare function tagFindingsWithServiceSections(findings: RawFinding[], sections: ServiceSection[], opts?: {
+    monorepoPackageSectionPathDepth?: number;
+}): void;

package/dist/src/core/sectioning/discover-service-sections.js

@@ -0,0 +1,468 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferTerraformStackSectionPathDepth = inferTerraformStackSectionPathDepth;
+exports.inferMonorepoPackageSectionPathDepth = inferMonorepoPackageSectionPathDepth;
+exports.rollupSectionIdToMonorepoDepth = rollupSectionIdToMonorepoDepth;
+exports.discoverServiceSections = discoverServiceSections;
+exports.tagFindingsWithServiceSections = tagFindingsWithServiceSections;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const gitignore_1 = require("../../ingest/gitignore");
+const scan_exclusions_1 = require("../../patterns/scan-exclusions");
+function patternToRegex(pattern) {
+    let escaped = pattern.replace(/[-\\^$+?.()|[\]{}*?]/g, "\\$&");
+    escaped = escaped.replace(/\\\*\\\*/g, ".*");
+    escaped = escaped.replace(/\\\*/g, "[^/]*");
+    escaped = escaped.replace(/\\\?/g, "[^/]");
+    return new RegExp(`^${escaped}$`);
+}
+function normalizeUserPattern(pattern) {
+    return (0, gitignore_1.toPosixPath)(pattern.replace(/^\.\/+/, "").trim());
+}
+function isExcludedByUserPatterns(relativePath, excludePaths) {
+    const rel = (0, gitignore_1.toPosixPath)(relativePath);
+    for (const rawPattern of excludePaths) {
+        const pattern = normalizeUserPattern(rawPattern);
+        if (!pattern)
+            continue;
+        if (pattern.endsWith("/**")) {
+            const prefix = pattern.slice(0, -3).replace(/\/$/, "");
+            if (rel === prefix || rel.startsWith(`${prefix}/`))
+                return true;
+        }
+        if (patternToRegex(pattern).test(rel))
+            return true;
+    }
+    return false;
+}
+async function walkForManifests(currentDirAbs, rootDirAbs, excludePaths, accumulatedGitignoreRules, onManifestRelPath) {
+    const gitignoreRules = await (0, gitignore_1.gitignoreRulesForDir)(currentDirAbs, accumulatedGitignoreRules);
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(currentDirAbs, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const entryPathAbs = path_1.default.join(currentDirAbs, entry.name);
+        const entryRelPosix = (0, gitignore_1.toPosixPath)(path_1.default.relative(rootDirAbs, entryPathAbs));
+        if (entry.isDirectory()) {
+            if ((0, scan_exclusions_1.shouldSkipDirectoryName)(entry.name))
+                continue;
+            if (entryRelPosix &&
+                isExcludedByUserPatterns(entryRelPosix, excludePaths)) {
+                continue;
+            }
+            if ((0, gitignore_1.isPathIgnored)(entryPathAbs, true, gitignoreRules)) {
+                continue;
+            }
+            await walkForManifests(entryPathAbs, rootDirAbs, excludePaths, gitignoreRules, onManifestRelPath);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        if ((0, gitignore_1.isPathIgnored)(entryPathAbs, false, gitignoreRules)) {
+            continue;
+        }
+        const name = entry.name;
+        const lower = name.toLowerCase();
+        const isTsManifest = lower === "package.json";
+        const isRequirements = lower.startsWith("requirements") && lower.endsWith(".txt");
+        const isPyproject = lower === "pyproject.toml";
+        const isPipfile = lower === "pipfile";
+        if (!isTsManifest && !isRequirements && !isPyproject && !isPipfile) {
+            continue;
+        }
+        const manifestRel = path_1.default.relative(rootDirAbs, entryPathAbs);
+        if (manifestRel.startsWith("..") || path_1.default.isAbsolute(manifestRel))
+            continue;
+        if (isExcludedByUserPatterns((0, gitignore_1.toPosixPath)(manifestRel), excludePaths)) {
+            continue;
+        }
+        onManifestRelPath((0, gitignore_1.toPosixPath)(manifestRel));
+    }
+}
+/**
+ * True for Terraform HCL module files in a directory (any `*.tf`).
+ * Excludes `.tf.json` (Terraform JSON syntax). Does not treat `.tfvars` as a
+ * module root marker — those files use a different suffix.
+ */
+function isTerraformConfigFileName(fileName) {
+    const lower = fileName.toLowerCase();
+    if (!lower.endsWith(".tf"))
+        return false;
+    if (lower.endsWith(".tf.json"))
+        return false;
+    return true;
+}
+async function walkForTerraformConfigFiles(currentDirAbs, rootDirAbs, excludePaths, accumulatedGitignoreRules, onTerraformConfigRelPosix) {
+    const gitignoreRules = await (0, gitignore_1.gitignoreRulesForDir)(currentDirAbs, accumulatedGitignoreRules);
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(currentDirAbs, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const entryPathAbs = path_1.default.join(currentDirAbs, entry.name);
+        const entryRelPosix = (0, gitignore_1.toPosixPath)(path_1.default.relative(rootDirAbs, entryPathAbs));
+        if (entry.isDirectory()) {
+            if ((0, scan_exclusions_1.shouldSkipDirectoryName)(entry.name))
+                continue;
+            if (entryRelPosix &&
+                isExcludedByUserPatterns(entryRelPosix, excludePaths)) {
+                continue;
+            }
+            if ((0, gitignore_1.isPathIgnored)(entryPathAbs, true, gitignoreRules)) {
+                continue;
+            }
+            await walkForTerraformConfigFiles(entryPathAbs, rootDirAbs, excludePaths, gitignoreRules, onTerraformConfigRelPosix);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        if ((0, gitignore_1.isPathIgnored)(entryPathAbs, false, gitignoreRules)) {
+            continue;
+        }
+        if (!isTerraformConfigFileName(entry.name))
+            continue;
+        const manifestRel = path_1.default.relative(rootDirAbs, entryPathAbs);
+        if (manifestRel.startsWith("..") || path_1.default.isAbsolute(manifestRel))
+            continue;
+        const relPosix = (0, gitignore_1.toPosixPath)(manifestRel);
+        if (isExcludedByUserPatterns(relPosix, excludePaths))
+            continue;
+        onTerraformConfigRelPosix(relPosix);
+    }
+}
+function sectionKeyFromDir(sectionDirPosix) {
+    // dirname('package.json') === '.' in POSIX; treat it as scan-root.
+    if (!sectionDirPosix || sectionDirPosix === ".")
+        return "root";
+    return sectionDirPosix;
+}
+function labelFromPackageName(packageName, fallbackBasename) {
+    const trimmed = packageName.trim();
+    if (!trimmed)
+        return fallbackBasename;
+    const slash = trimmed.lastIndexOf("/");
+    const base = slash >= 0 ? trimmed.slice(slash + 1) : trimmed;
+    const withoutScope = base.replace(/^@/, "").trim();
+    return withoutScope || fallbackBasename;
+}
+function labelFromSectionDir(sectionDirPosix, packageName) {
+    const key = sectionKeyFromDir(sectionDirPosix);
+    if (key === "root")
+        return "root";
+    const basename = path_1.default.posix.basename(sectionDirPosix);
+    if (packageName)
+        return labelFromPackageName(packageName, basename);
+    return basename;
+}
+async function readPackageJsonName(manifestAbsPath) {
+    try {
+        const raw = await promises_1.default.readFile(manifestAbsPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.name === "string" && parsed.name.trim()) {
+            return parsed.name.trim();
+        }
+    }
+    catch {
+        // ignore unreadable or invalid package.json
+    }
+    return undefined;
+}
+function sectionHasPackageManifest(manifestPaths) {
+    return manifestPaths.some((p) => path_1.default.posix.basename(p) === "package.json");
+}
+function manifestPathIsTerraformConfig(manifestRelPosix) {
+    return isTerraformConfigFileName(path_1.default.posix.basename(manifestRelPosix));
+}
+/** True when `manifestPaths` are exclusively `*.tf` files (no app manifests). */
+function sectionIsTerraformOnlyStack(manifestPaths) {
+    if (manifestPaths.length === 0)
+        return false;
+    if (sectionHasPackageManifest(manifestPaths))
+        return false;
+    return manifestPaths.every(manifestPathIsTerraformConfig);
+}
+function roleFromSectionDir(sectionDirPosix) {
+    const key = sectionKeyFromDir(sectionDirPosix);
+    return key === "root" ? "root" : "service";
+}
+function registerTerraformStackSections(bySectionDir, tfConfigRelPaths, tfDepth, excludePaths) {
+    for (const tfConfigRelPosix of tfConfigRelPaths) {
+        const dir = path_1.default.posix.dirname(tfConfigRelPosix);
+        const sectionDir = dir === "." ? "" : dir;
+        if (!sectionDir)
+            continue;
+        const segmentCount = sectionDir.split("/").length;
+        if (segmentCount !== tfDepth)
+            continue;
+        if (isExcludedByUserPatterns(sectionDir, excludePaths))
+            continue;
+        const existing = bySectionDir.get(sectionDir);
+        if (existing) {
+            if (!existing.manifestPaths.includes(tfConfigRelPosix)) {
+                existing.manifestPaths.push(tfConfigRelPosix);
+            }
+        }
+        else {
+            bySectionDir.set(sectionDir, { manifestPaths: [tfConfigRelPosix] });
+        }
+    }
+}
+/**
+ * Pick path depth `N` where the most Terraform stack directories live.
+ * Prefers directories that contain `main.tf`; falls back to any `*.tf` directory.
+ * Tie-break: deeper `N` (more specific stack roots).
+ */
+function inferTerraformStackSectionPathDepth(tfConfigRelPaths) {
+    const mainTfDirs = new Set();
+    const anyTfDirs = new Set();
+    for (const rel of tfConfigRelPaths) {
+        const dir = path_1.default.posix.dirname(rel);
+        if (!dir || dir === ".")
+            continue;
+        anyTfDirs.add(dir);
+        if (path_1.default.posix.basename(rel).toLowerCase() === "main.tf") {
+            mainTfDirs.add(dir);
+        }
+    }
+    const stackDirs = mainTfDirs.size > 0 ? mainTfDirs : anyTfDirs;
+    if (stackDirs.size === 0)
+        return undefined;
+    const depthCounts = new Map();
+    for (const dir of stackDirs) {
+        const depth = dir.split("/").length;
+        depthCounts.set(depth, (depthCounts.get(depth) ?? 0) + 1);
+    }
+    let bestDepth;
+    let bestCount = 0;
+    for (const [depth, count] of depthCounts) {
+        if (count > bestCount ||
+            (count === bestCount &&
+                bestDepth != null &&
+                depth > bestDepth)) {
+            bestCount = count;
+            bestDepth = depth;
+        }
+    }
+    return bestDepth;
+}
+/**
+ * Pick workspace package depth: shallowest path depth with at least two
+ * `package.json` directories (typical `packages/*` monorepo layout).
+ */
+function inferMonorepoPackageSectionPathDepth(packageJsonRelPaths) {
+    const dirs = new Set();
+    for (const rel of packageJsonRelPaths) {
+        const dir = path_1.default.posix.dirname(rel);
+        if (!dir || dir === ".")
+            continue;
+        dirs.add(dir);
+    }
+    if (dirs.size < 2)
+        return undefined;
+    const depthCounts = new Map();
+    for (const dir of dirs) {
+        const depth = dir.split("/").length;
+        depthCounts.set(depth, (depthCounts.get(depth) ?? 0) + 1);
+    }
+    let bestDepth;
+    let bestCount = 0;
+    for (const [depth, count] of depthCounts) {
+        if (count < 2)
+            continue;
+        if (count > bestCount ||
+            (count === bestCount && bestDepth != null && depth < bestDepth)) {
+            bestCount = count;
+            bestDepth = depth;
+        }
+    }
+    return bestDepth;
+}
+function rollupSectionIdToMonorepoDepth(sectionId, depth) {
+    if (sectionId === "root" || !sectionId.includes("/"))
+        return sectionId;
+    const segments = sectionId.split("/");
+    if (segments.length <= depth)
+        return sectionId;
+    return segments.slice(0, depth).join("/");
+}
+function ensureMonorepoParentPackageSections(bySectionDir, monorepoDepth) {
+    for (const sectionDir of [...bySectionDir.keys()]) {
+        if (!sectionDir)
+            continue;
+        const segments = sectionDir.split("/");
+        if (segments.length <= monorepoDepth)
+            continue;
+        const parentDir = segments.slice(0, monorepoDepth).join("/");
+        if (!bySectionDir.has(parentDir)) {
+            bySectionDir.set(parentDir, { manifestPaths: [] });
+        }
+    }
+}
+function markPrimaryMonorepoPackageSections(sections, monorepoDepth) {
+    if (monorepoDepth == null)
+        return;
+    for (const section of sections) {
+        if (section.role !== "service" || !section.sectionDir)
+            continue;
+        section.isPrimaryMonorepoPackage =
+            section.sectionDir.split("/").length === monorepoDepth;
+    }
+}
+async function discoverServiceSections(rootPath, opts = {}) {
+    const rootDirAbs = path_1.default.resolve(rootPath);
+    const excludePaths = opts.excludePaths ?? [];
+    // Keyed by directory (relative to root). Root uses ''.
+    const bySectionDir = new Map();
+    const packageJsonRelPaths = [];
+    await walkForManifests(rootDirAbs, rootDirAbs, excludePaths, [], (manifestRelPosix) => {
+        const dir = path_1.default.posix.dirname(manifestRelPosix);
+        const sectionDir = dir === "." ? "" : dir;
+        const isPackageJson = path_1.default.posix.basename(manifestRelPosix) === "package.json";
+        if (isPackageJson)
+            packageJsonRelPaths.push(manifestRelPosix);
+        const entry = bySectionDir.get(sectionDir);
+        if (entry) {
+            entry.manifestPaths.push(manifestRelPosix);
+        }
+        else {
+            bySectionDir.set(sectionDir, { manifestPaths: [manifestRelPosix] });
+        }
+    });
+    for (const manifestRelPosix of packageJsonRelPaths) {
+        const dir = path_1.default.posix.dirname(manifestRelPosix);
+        const sectionDir = dir === "." ? "" : dir;
+        const entry = bySectionDir.get(sectionDir);
+        if (!entry)
+            continue;
+        const packageName = await readPackageJsonName(path_1.default.join(rootDirAbs, manifestRelPosix));
+        if (packageName)
+            entry.packageName = packageName;
+    }
+    let monorepoDepth = opts.monorepoPackageSectionPathDepth;
+    let inferredMonorepoPackageSectionPathDepth;
+    const autoInferMonorepo = opts.autoInferMonorepoPackageSectionPathDepth !== false;
+    if (monorepoDepth == null &&
+        autoInferMonorepo &&
+        packageJsonRelPaths.length >= 2) {
+        const inferred = inferMonorepoPackageSectionPathDepth(packageJsonRelPaths);
+        if (inferred != null && inferred > 0) {
+            monorepoDepth = inferred;
+            inferredMonorepoPackageSectionPathDepth = inferred;
+            ensureMonorepoParentPackageSections(bySectionDir, monorepoDepth);
+        }
+    }
+    else if (typeof monorepoDepth === "number" &&
+        Number.isInteger(monorepoDepth) &&
+        monorepoDepth > 0) {
+        ensureMonorepoParentPackageSections(bySectionDir, monorepoDepth);
+    }
+    const tfConfigRelPaths = [];
+    await walkForTerraformConfigFiles(rootDirAbs, rootDirAbs, excludePaths, [], (rel) => tfConfigRelPaths.push(rel));
+    let tfDepth = opts.terraformStackSectionPathDepth;
+    let inferredTerraformStackSectionPathDepth;
+    const autoInfer = opts.autoInferTerraformStackSectionPathDepth !== false;
+    if (tfDepth == null &&
+        autoInfer &&
+        tfConfigRelPaths.length > 0) {
+        const inferred = inferTerraformStackSectionPathDepth(tfConfigRelPaths);
+        if (inferred != null && inferred > 0) {
+            tfDepth = inferred;
+            inferredTerraformStackSectionPathDepth = inferred;
+        }
+    }
+    if (typeof tfDepth === "number" &&
+        Number.isInteger(tfDepth) &&
+        tfDepth > 0) {
+        registerTerraformStackSections(bySectionDir, tfConfigRelPaths, tfDepth, excludePaths);
+    }
+    // Always include a fallback section to avoid "no section_id" surprises.
+    if (!bySectionDir.has(""))
+        bySectionDir.set("", { manifestPaths: [] });
+    const sections = Array.from(bySectionDir.entries())
+        .map(([sectionDir, v]) => {
+        const id = sectionKeyFromDir(sectionDir);
+        const isTerraformStack = sectionIsTerraformOnlyStack(v.manifestPaths);
+        return {
+            id,
+            label: labelFromSectionDir(sectionDir, v.packageName),
+            role: roleFromSectionDir(sectionDir),
+            sectionDir,
+            manifestPaths: v.manifestPaths.sort((a, b) => a.localeCompare(b)),
+            packageName: v.packageName,
+            ...(isTerraformStack ? { isTerraformStack: true } : {}),
+        };
+    })
+        .sort((a, b) => a.id.localeCompare(b.id));
+    markPrimaryMonorepoPackageSections(sections, monorepoDepth);
+    return {
+        sections,
+        inferredTerraformStackSectionPathDepth,
+        inferredMonorepoPackageSectionPathDepth,
+        monorepoPackageSectionPathDepth: monorepoDepth,
+    };
+}
+function findNearestSectionForFile(filePathRelPosix, sections) {
+    // Longest prefix match on section directory.
+    let best;
+    let bestLen = -1;
+    for (const s of sections) {
+        if (!s.sectionDir)
+            continue; // root handled as fallback
+        if (filePathRelPosix === s.sectionDir ||
+            filePathRelPosix.startsWith(`${s.sectionDir}/`)) {
+            if (s.sectionDir.length > bestLen) {
+                best = s;
+                bestLen = s.sectionDir.length;
+            }
+        }
+    }
+    return best ?? sections.find((s) => s.id === "root") ?? sections[0];
+}
+function resolveSectionForFinding(filePathRelPosix, sections, monorepoRollupDepth) {
+    const section = findNearestSectionForFile(filePathRelPosix, sections);
+    if (monorepoRollupDepth == null ||
+        !section.sectionDir ||
+        !sectionHasPackageManifest(section.manifestPaths)) {
+        return section;
+    }
+    const segmentCount = section.sectionDir.split("/").length;
+    if (segmentCount <= monorepoRollupDepth)
+        return section;
+    const rolledId = rollupSectionIdToMonorepoDepth(section.id, monorepoRollupDepth);
+    const rolled = sections.find((s) => s.id === rolledId);
+    if (rolled)
+        return rolled;
+    return {
+        ...section,
+        id: rolledId,
+        label: path_1.default.posix.basename(rolledId),
+        sectionDir: rolledId,
+        isPrimaryMonorepoPackage: true,
+    };
+}
+function tagFindingsWithServiceSections(findings, sections, opts) {
+    if (!findings.length)
+        return;
+    const monorepoRollupDepth = opts?.monorepoPackageSectionPathDepth;
+    for (const finding of findings) {
+        const filePathRelPosix = (0, gitignore_1.toPosixPath)(finding.location.filePath);
+        const section = resolveSectionForFinding(filePathRelPosix, sections, monorepoRollupDepth);
+        // Thread through classification via component.properties.
+        finding.properties.section_id = section.id;
+        finding.properties.section_label = section.label;
+        finding.properties.section_role = section.role;
+        if (section.packageName) {
+            finding.properties.package_name = section.packageName;
+        }
+    }
+}

package/dist/src/core/sectioning/section-runtime.d.ts

@@ -0,0 +1,21 @@
+import type { DetectedComponent } from "../types/component";
+import type { ServiceSection } from "./discover-service-sections";
+/** True when this section discovered a `package.json` under `sectionDir`. */
+export declare function sectionHasPackageJsonManifest(section: Pick<ServiceSection, "manifestPaths">): boolean;
+/** Generator templates / placeholder manifests (not deployable workspace apps). */
+export declare function isScaffoldOrTemplatePackageSection(section: Pick<ServiceSection, "id" | "packageName" | "sectionDir">): boolean;
+/** At least one classified component is scoped to this section. */
+export declare function sectionHasClassifiedComponents(components: DetectedComponent[], sectionId: string): boolean;
+export declare function isConcreteServiceSectionId(sectionId: string | undefined): boolean;
+export { TERRAFORM_DETECTED_FROM_PATTERNS, } from "../terraform/component-predicates";
+/** Classified from Terraform analysis (HCL or show-json), not application source code. */
+export declare function isTerraformDerivedComponent(component: DetectedComponent): boolean;
+/** Section created for a Terraform stack root or module directory. */
+export declare function isTerraformStackSection(section: Pick<ServiceSection, "id" | "sectionDir" | "isTerraformStack">): boolean;
+export declare function sectionHasRuntimeCodeComponents(components: DetectedComponent[], sectionId: string): boolean;
+/**
+ * Whether a workspace section should receive a synthetic application hub and
+ * default User actor (tooling-only packages like cli/docs/utils are skipped).
+ */
+export declare function sectionQualifiesForSyntheticApplication(section: ServiceSection, components: DetectedComponent[]): boolean;
+export declare function shouldInjectUserActorForMainApp(mainApp: DetectedComponent, components: DetectedComponent[]): boolean;