@dataparade/cli 0.0.1

package/dist/src/ai-enrichment/tools/index.d.ts

@@ -0,0 +1,39 @@
+import type { RawFinding } from "../../core/types/detection";
+import type { FileInfo } from "../../core/types/file";
+import type { ServiceSection } from "../../core/sectioning/discover-service-sections";
+import type { DetectedComponent } from "../../core/types/component";
+import type { DetectedDataFlow } from "../../core/types/data-flow";
+import type { AiInferenceCandidate, AiProposal } from "../types";
+export interface AiScanContext {
+    components: DetectedComponent[];
+    dataFlows: DetectedDataFlow[];
+    findings: RawFinding[];
+    files: FileInfo[];
+    sections: ServiceSection[];
+}
+export interface AgentTooling {
+    getScanContext(): AiScanContext;
+    listCandidates(filter?: {
+        candidateType?: AiInferenceCandidate["candidateType"];
+        minPriority?: number;
+    }): AiInferenceCandidate[];
+    getGraphNeighborhood(nodeOrFlowId: string, depth: number): {
+        components: DetectedComponent[];
+        dataFlows: DetectedDataFlow[];
+    };
+    readSnippet(filePath: string, startLine: number, endLine: number): string | undefined;
+    searchInFiles(query: string, scope?: string[]): Array<{
+        filePath: string;
+        line: number;
+        snippet: string;
+    }>;
+    getSymbolContext(symbol: string, filePath: string): string | undefined;
+    validateProposal(proposal: AiProposal): {
+        ok: true;
+    } | {
+        ok: false;
+        reason: string;
+    };
+    emitProposal(proposal: AiProposal): void;
+}
+export declare function createAgentTooling(scanContext: AiScanContext, candidates: AiInferenceCandidate[], proposalSink: AiProposal[]): AgentTooling;

package/dist/src/ai-enrichment/tools/index.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgentTooling = createAgentTooling;
+const scan_paths_1 = require("../scan-paths");
+function fileLines(content) {
+    return content.split(/\r?\n/);
+}
+function createAgentTooling(scanContext, candidates, proposalSink) {
+    const byFilePath = new Map(scanContext.files.map((file) => [file.path, file]));
+    return {
+        getScanContext: () => scanContext,
+        listCandidates: (filter) => candidates.filter((candidate) => {
+            if (filter?.candidateType && candidate.candidateType !== filter.candidateType) {
+                return false;
+            }
+            if (typeof filter?.minPriority === "number" &&
+                candidate.priority < filter.minPriority) {
+                return false;
+            }
+            return true;
+        }),
+        getGraphNeighborhood: (nodeOrFlowId, depth) => {
+            const targetFlow = scanContext.dataFlows.find((flow) => flow.id === nodeOrFlowId);
+            const startNodes = new Set();
+            if (targetFlow) {
+                startNodes.add(targetFlow.sourceComponentId);
+                startNodes.add(targetFlow.targetComponentId);
+            }
+            else {
+                startNodes.add(nodeOrFlowId);
+            }
+            const frontier = new Set(startNodes);
+            const visited = new Set(startNodes);
+            for (let i = 0; i < Math.max(1, depth); i += 1) {
+                const next = new Set();
+                for (const flow of scanContext.dataFlows) {
+                    if (frontier.has(flow.sourceComponentId)) {
+                        next.add(flow.targetComponentId);
+                    }
+                    if (frontier.has(flow.targetComponentId)) {
+                        next.add(flow.sourceComponentId);
+                    }
+                }
+                for (const nodeId of next) {
+                    visited.add(nodeId);
+                }
+            }
+            return {
+                components: scanContext.components.filter((component) => visited.has(component.id)),
+                dataFlows: scanContext.dataFlows.filter((flow) => visited.has(flow.sourceComponentId) || visited.has(flow.targetComponentId)),
+            };
+        },
+        readSnippet: (filePath, startLine, endLine) => {
+            const file = byFilePath.get(filePath);
+            if (!file)
+                return undefined;
+            const lines = fileLines(file.content);
+            const start = Math.max(1, startLine);
+            const end = Math.max(start, endLine);
+            return lines.slice(start - 1, end).join("\n");
+        },
+        searchInFiles: (query, scope) => {
+            const q = query.toLowerCase();
+            return scanContext.files
+                .filter((file) => !scope || scope.length === 0
+                ? true
+                : scope.some((prefix) => file.path.startsWith(prefix)))
+                .flatMap((file) => {
+                const lines = fileLines(file.content);
+                const matches = [];
+                lines.forEach((line, idx) => {
+                    if (line.toLowerCase().includes(q)) {
+                        matches.push({
+                            filePath: file.path,
+                            line: idx + 1,
+                            snippet: line.trim().slice(0, 240),
+                        });
+                    }
+                });
+                return matches;
+            })
+                .slice(0, 50);
+        },
+        getSymbolContext: (symbol, filePath) => {
+            const file = byFilePath.get(filePath);
+            if (!file)
+                return undefined;
+            const lines = fileLines(file.content);
+            const idx = lines.findIndex((line) => line.includes(symbol));
+            if (idx < 0)
+                return undefined;
+            const start = Math.max(0, idx - 4);
+            const end = Math.min(lines.length, idx + 5);
+            return lines.slice(start, end).join("\n");
+        },
+        validateProposal: (proposal) => {
+            if (proposal.evidence.length === 0) {
+                return { ok: false, reason: "missing_evidence" };
+            }
+            if (proposal.confidence.score < 0 || proposal.confidence.score > 1) {
+                return { ok: false, reason: "invalid_confidence_range" };
+            }
+            const files = scanContext.files;
+            if (proposal.provider !== "mock" && files.length > 0) {
+                for (const ev of proposal.evidence) {
+                    const fp = ev.filePath.trim().toLowerCase();
+                    if (!fp || fp === "unknown") {
+                        return { ok: false, reason: "evidence_path_invalid" };
+                    }
+                    if (!(0, scan_paths_1.resolveScannedFileExact)(files, ev.filePath)) {
+                        return { ok: false, reason: "evidence_path_not_in_scan" };
+                    }
+                }
+            }
+            return { ok: true };
+        },
+        emitProposal: (proposal) => {
+            proposalSink.push(proposal);
+        },
+    };
+}

package/dist/src/ai-enrichment/types.d.ts

@@ -0,0 +1,170 @@
+import type { ServiceSection } from "../core/sectioning/discover-service-sections";
+import type { DetectedComponent } from "../core/types/component";
+import type { RawFinding } from "../core/types/detection";
+import type { DataFlowType, DetectedDataFlow } from "../core/types/data-flow";
+import type { FileInfo } from "../core/types/file";
+export type AiCandidateType = "third_party" | "node_property" | "flow_direction" | "missing_interaction";
+export type AiAgentName = "tpAgent" | "propertyAgent" | "directionAgent" | "interactionAgent";
+/** User-facing inference presets (see `providers/presets.ts`). */
+export declare const AI_PROVIDER_IDS: readonly ["openai", "anthropic", "gemini", "openrouter", "local", "mock"];
+export type AiProviderId = (typeof AI_PROVIDER_IDS)[number];
+/** `third_party_only`: after rules, only run AI enrichment for third-party nodes (every one). */
+export type AiInferenceScope = "default" | "third_party_only";
+export interface AiInferenceCandidate {
+    id: string;
+    candidateType: AiCandidateType;
+    priority: number;
+    componentId?: string;
+    flowId?: string;
+    missingFields: string[];
+    rationale: string;
+    hints: string[];
+}
+export interface AiConfidence {
+    score: number;
+    band: "high" | "medium" | "low";
+}
+export interface EvidenceRef {
+    filePath: string;
+    startLine: number;
+    endLine: number;
+    reason: string;
+}
+export interface ComponentPatch {
+    kind: "component_patch";
+    targetComponentId: string;
+    candidateType: AiCandidateType;
+    setSubType?: string;
+    setDescription?: string;
+    setProperties: Record<string, unknown>;
+    propertyEvidence?: Record<string, EvidenceRef[]>;
+    confidence: AiConfidence;
+    evidence: EvidenceRef[];
+    provider: AiProviderId;
+    model: string;
+    agent: AiAgentName;
+}
+export interface FlowPatch {
+    kind: "flow_patch";
+    candidateType: AiCandidateType;
+    targetFlowId?: string;
+    insertIfMissing?: boolean;
+    sourceComponentId?: string;
+    targetComponentId?: string;
+    setType?: DataFlowType;
+    setDirection?: "forward" | "reverse";
+    setMethod?: string;
+    setEndpoint?: string;
+    setDescription?: string;
+    setProperties?: Partial<DetectedDataFlow>;
+    confidence: AiConfidence;
+    evidence: EvidenceRef[];
+    provider: AiProviderId;
+    model: string;
+    agent: AiAgentName;
+}
+export type AiProposal = ComponentPatch | FlowPatch;
+export interface MergeProvenance {
+    source: "rule" | "ai_agent";
+    provider?: string;
+    model?: string;
+    agent?: AiAgentName;
+    candidateType?: AiCandidateType;
+    confidence: number;
+    confidenceBand?: "high" | "medium" | "low";
+    evidence: EvidenceRef[];
+}
+export interface AiMergeResult {
+    components: DetectedComponent[];
+    dataFlows: DetectedDataFlow[];
+    appliedProposalIds: string[];
+    rejectedProposalIds: Array<{
+        proposalId: string;
+        reason: string;
+    }>;
+    provenanceByTarget: Record<string, MergeProvenance>;
+}
+export interface AiMergeThresholds {
+    minComponentPatchConfidence: number;
+    minFlowPatchConfidence: number;
+    minInsertFlowConfidence: number;
+}
+export interface InferencePlannerOptions {
+    maxCandidatesPerAgent?: number;
+    totalBudgetTokens: number;
+    maxModelCalls: number;
+}
+export interface AiQueuePlan {
+    agent: AiAgentName;
+    queue: AiInferenceCandidate[];
+    budgetTokens: number;
+    maxModelCalls: number;
+}
+export interface InferencePlannerResult {
+    queues: AiQueuePlan[];
+    droppedCandidates: Array<{
+        candidateId: string;
+        reason: string;
+    }>;
+}
+export interface RunInferencePipelineInput {
+    components: DetectedComponent[];
+    dataFlows: DetectedDataFlow[];
+    sections?: ServiceSection[];
+    /** Structural scan file bodies; used for prompt excerpts and agent tooling. */
+    files?: FileInfo[];
+    findings?: RawFinding[];
+    inferenceScope?: AiInferenceScope;
+    plannerOptions?: Partial<InferencePlannerOptions>;
+}
+export interface GenerateProposalsContext {
+    candidates: AiInferenceCandidate[];
+    plan: InferencePlannerResult;
+    components: DetectedComponent[];
+    dataFlows: DetectedDataFlow[];
+    sections?: ServiceSection[];
+    files?: FileInfo[];
+    findings?: RawFinding[];
+}
+export interface RunInferencePipelineOptions {
+    generateProposals?: (context: GenerateProposalsContext) => Promise<{
+        proposals: Array<{
+            id: string;
+            proposal: AiProposal;
+        }>;
+        usageSummary?: AiInferenceUsageSummary;
+    }>;
+}
+export interface InferencePipelineResult {
+    candidates: AiInferenceCandidate[];
+    plan: InferencePlannerResult;
+    proposals: Array<{
+        id: string;
+        proposal: AiProposal;
+    }>;
+    usageSummary?: AiInferenceUsageSummary;
+    mergeResult: AiMergeResult;
+}
+export interface AiInferenceUsageSummary {
+    providerCalls: number;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    estimatedCostUsd?: number;
+    agenticTrace?: AiCandidateAgentTrace[];
+}
+export interface AiToolCallTrace {
+    round: number;
+    action: "seed_files" | "search_text" | "expand_imports" | "provider_infer" | "finalize";
+    detail: string;
+    filesTouched?: string[];
+    stats?: Record<string, number>;
+}
+export interface AiCandidateAgentTrace {
+    candidateId: string;
+    componentId?: string;
+    filesReviewed: string[];
+    rounds: number;
+    toolCalls: AiToolCallTrace[];
+    finalProposalCount: number;
+}

package/dist/src/ai-enrichment/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI_PROVIDER_IDS = void 0;
+/** User-facing inference presets (see `providers/presets.ts`). */
+exports.AI_PROVIDER_IDS = [
+    "openai",
+    "anthropic",
+    "gemini",
+    "openrouter",
+    "local",
+    "mock",
+];

package/dist/src/analyzers/python/dependency-manifests.d.ts

@@ -0,0 +1,8 @@
+import type { RawFinding } from "../../core/types/detection";
+import { type ManifestScanBudgetOptions } from "../shared/manifest-budgets";
+export interface PythonManifestPackages {
+    manifestRelativePath: string;
+    packages: string[];
+}
+export declare function parsePythonDependencyManifests(rootPath: string, opts?: ManifestScanBudgetOptions): Promise<PythonManifestPackages[]>;
+export declare function detectPythonPatternsFromDependencyManifests(rootPath: string, opts?: ManifestScanBudgetOptions): Promise<RawFinding[]>;

package/dist/src/analyzers/python/dependency-manifests.js

@@ -0,0 +1,131 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePythonDependencyManifests = parsePythonDependencyManifests;
+exports.detectPythonPatternsFromDependencyManifests = detectPythonPatternsFromDependencyManifests;
+const promises_1 = __importDefault(require("fs/promises"));
+const path = __importStar(require("path"));
+const engine_1 = require("../../patterns/engine");
+const manifest_budgets_1 = require("../shared/manifest-budgets");
+const manifest_fs_1 = require("../shared/manifest-fs");
+const manifest_parsers_1 = require("./manifest-parsers");
+function toPosixPath(p) {
+    return p.split(path.sep).join("/");
+}
+function createManifestFileInfo(manifestRelativePath) {
+    return {
+        path: manifestRelativePath,
+        name: path.basename(manifestRelativePath),
+        content: "",
+        language: "python",
+        size: 0,
+    };
+}
+async function parsePythonDependencyManifests(rootPath, opts) {
+    const rootDir = path.resolve(rootPath);
+    const manifests = [];
+    const state = (0, manifest_budgets_1.budgetStateFromOptions)(opts);
+    await (0, manifest_fs_1.walkForManifests)(rootDir, manifests, {
+        rootDir,
+        state,
+        excludePaths: opts?.excludePaths,
+        isManifestFile: (_entry, entryPath) => {
+            const name = path.basename(entryPath);
+            const lower = name.toLowerCase();
+            const isRequirements = lower.startsWith("requirements") && lower.endsWith(".txt");
+            const isPyproject = lower === "pyproject.toml";
+            const isPipfile = name === "Pipfile";
+            return isRequirements || isPyproject || isPipfile;
+        },
+    });
+    const byManifest = [];
+    let bytesRead = 0;
+    const maxBytes = state.maxTotalManifestReadBytes;
+    for (const manifestAbsPath of manifests) {
+        if (bytesRead >= maxBytes)
+            break;
+        const lower = path.basename(manifestAbsPath).toLowerCase();
+        const manifestRelativePath = toPosixPath(path.relative(rootDir, manifestAbsPath));
+        let raw;
+        try {
+            raw = await promises_1.default.readFile(manifestAbsPath, "utf8");
+        }
+        catch {
+            continue;
+        }
+        bytesRead += raw.length;
+        let packages = [];
+        if (lower.startsWith("requirements") && lower.endsWith(".txt")) {
+            packages = (0, manifest_parsers_1.extractPackagesFromRequirementsTxt)(raw);
+        }
+        else if (lower === "pyproject.toml") {
+            packages = (0, manifest_parsers_1.extractPackagesFromPyprojectToml)(raw);
+        }
+        else if (path.basename(manifestAbsPath).toLowerCase() === "pipfile") {
+            packages = (0, manifest_parsers_1.extractPackagesFromPipfile)(raw);
+        }
+        // Skip empty manifests to avoid generating empty matchPatterns runs.
+        if (packages.length === 0)
+            continue;
+        byManifest.push({
+            manifestRelativePath,
+            packages: Array.from(new Set(packages)),
+        });
+    }
+    return byManifest;
+}
+async function detectPythonPatternsFromDependencyManifests(rootPath, opts) {
+    const manifestPackages = await parsePythonDependencyManifests(rootPath, opts);
+    if (manifestPackages.length === 0)
+        return [];
+    const findings = [];
+    for (const manifest of manifestPackages) {
+        const manifestFile = createManifestFileInfo(manifest.manifestRelativePath);
+        const imports = manifest.packages.map((p) => ({
+            module: p,
+            names: [p],
+        }));
+        findings.push(...(0, engine_1.matchPatterns)({
+            language: "python",
+            file: manifestFile,
+            normalizedPath: manifestFile.path,
+            imports,
+        }));
+    }
+    return findings;
+}

package/dist/src/analyzers/python/detector.d.ts

@@ -0,0 +1,3 @@
+import type { FileInfo } from "../../core/types/file";
+import type { RawFinding } from "../../core/types/detection";
+export declare function detectPythonPatterns(file: FileInfo): RawFinding[];

package/dist/src/analyzers/python/detector.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPythonPatterns = detectPythonPatterns;
+const parser_1 = require("./parser");
+const property_inference_1 = require("../shared/property-inference");
+const patterns_1 = require("./patterns");
+function detectPythonPatterns(file) {
+    const moduleModel = (0, parser_1.parsePythonModule)(file);
+    if (moduleModel.file.language !== "python") {
+        return [];
+    }
+    const findings = [];
+    findings.push(...(0, patterns_1.detectPythonRoutePatterns)(moduleModel), ...(0, patterns_1.detectPythonDatabaseConnections)(moduleModel), ...(0, patterns_1.detectPythonExternalApiCalls)(moduleModel), ...(0, patterns_1.detectPythonAuthPatterns)(moduleModel), ...(0, patterns_1.detectPythonConfigAndEnvUsage)(moduleModel));
+    // Merge pattern-matched component properties (from YAML) into each finding.
+    for (const finding of findings) {
+        const detected = (0, property_inference_1.getPropertiesFromFinding)(finding, file.content);
+        if (Object.keys(detected).length > 0) {
+            finding.properties = { ...(finding.properties ?? {}), ...detected };
+        }
+    }
+    return findings;
+}

package/dist/src/analyzers/python/index.d.ts

@@ -0,0 +1,2 @@
+import type { Analyzer } from "../types";
+export declare function createPythonAnalyzer(): Analyzer;

package/dist/src/analyzers/python/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPythonAnalyzer = createPythonAnalyzer;
+const detector_1 = require("./detector");
+function createPythonAnalyzer() {
+    return {
+        detect(file) {
+            return (0, detector_1.detectPythonPatterns)(file);
+        },
+    };
+}

package/dist/src/analyzers/python/manifest-parsers.d.ts

@@ -0,0 +1,3 @@
+export declare function extractPackagesFromRequirementsTxt(content: string): string[];
+export declare function extractPackagesFromPyprojectToml(content: string): string[];
+export declare function extractPackagesFromPipfile(content: string): string[];

package/dist/src/analyzers/python/manifest-parsers.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPackagesFromRequirementsTxt = extractPackagesFromRequirementsTxt;
+exports.extractPackagesFromPyprojectToml = extractPackagesFromPyprojectToml;
+exports.extractPackagesFromPipfile = extractPackagesFromPipfile;
+function normalizePackageNameToken(raw) {
+    const s = raw.trim();
+    if (!s)
+        return null;
+    const beforeMarker = s.split(";")[0].trim();
+    const beforeAt = beforeMarker.includes(" @ ")
+        ? beforeMarker.split(" @ ")[0].trim()
+        : beforeMarker;
+    const beforeExtras = beforeAt.split("[")[0].trim();
+    const nameMatch = beforeExtras.match(/^([A-Za-z0-9][A-Za-z0-9_.-]*)\b/);
+    if (!nameMatch)
+        return null;
+    const token = nameMatch[1].toLowerCase();
+    if (!token || token === "python")
+        return null;
+    return token;
+}
+function stripInlineComment(line) {
+    const idx = line.indexOf("#");
+    if (idx === -1)
+        return line;
+    return line.slice(0, idx).trim();
+}
+function parseRequirementLineToPackageToken(line) {
+    const trimmed = stripInlineComment(line).trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("-") || trimmed.startsWith("--")) {
+        return null;
+    }
+    return normalizePackageNameToken(trimmed);
+}
+function extractPackagesFromRequirementsTxt(content) {
+    const pkgs = new Set();
+    const lines = content.split(/\r?\n/);
+    for (const rawLine of lines) {
+        const token = parseRequirementLineToPackageToken(rawLine);
+        if (token)
+            pkgs.add(token);
+    }
+    return Array.from(pkgs.values());
+}
+function parseTomlArrayOfStrings(raw) {
+    const matches = raw.match(/["']([^"']+)["']/g);
+    if (!matches)
+        return [];
+    return matches
+        .map((m) => m.trim())
+        .map((m) => m.replace(/^["']/, "").replace(/["']$/, ""));
+}
+function extractPackagesFromPyprojectToml(content) {
+    const pkgs = new Set();
+    const lines = content.split(/\r?\n/);
+    let currentSection = "";
+    const pushTokenFromSpec = (spec) => {
+        const token = normalizePackageNameToken(spec);
+        if (token)
+            pkgs.add(token);
+    };
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i].trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+        if (sectionMatch) {
+            currentSection = sectionMatch[1].trim();
+            continue;
+        }
+        if (currentSection === "project" && line.startsWith("dependencies")) {
+            const arrayMatch = line.match(/^dependencies\s*=\s*\[(.*)$/);
+            if (!arrayMatch)
+                continue;
+            const firstPart = arrayMatch[1] ?? "";
+            let arrayBody = firstPart;
+            while (!arrayBody.includes("]") && i + 1 < lines.length) {
+                i += 1;
+                arrayBody += `\n${lines[i]}`;
+            }
+            const strings = parseTomlArrayOfStrings(arrayBody);
+            for (const spec of strings)
+                pushTokenFromSpec(spec);
+            continue;
+        }
+        const poetryDepsSections = [
+            "tool.poetry.dependencies",
+            "tool.poetry.dev-dependencies",
+        ];
+        const isGroupDeps = currentSection.startsWith("tool.poetry.group.") &&
+            currentSection.endsWith(".dependencies");
+        if (poetryDepsSections.includes(currentSection) || isGroupDeps) {
+            const kv = line.match(/^([A-Za-z0-9][A-Za-z0-9_.-]*)\s*=\s*(.+)$/);
+            if (!kv)
+                continue;
+            const key = kv[1].trim();
+            pushTokenFromSpec(key);
+        }
+    }
+    return Array.from(pkgs.values());
+}
+function extractPackagesFromPipfile(content) {
+    const pkgs = new Set();
+    const lines = content.split(/\r?\n/);
+    let currentSection = null;
+    const pushKey = (key) => {
+        const token = normalizePackageNameToken(key);
+        if (token)
+            pkgs.add(token);
+    };
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+        if (sectionMatch) {
+            currentSection = sectionMatch[1] ?? null;
+            continue;
+        }
+        if (!currentSection)
+            continue;
+        const isPkgSection = currentSection === "packages" || currentSection === "dev-packages";
+        if (!isPkgSection)
+            continue;
+        const kv = line.match(/^([A-Za-z0-9][A-Za-z0-9_.-]*)\s*=/);
+        if (!kv)
+            continue;
+        pushKey(kv[1].trim());
+    }
+    return Array.from(pkgs.values());
+}