@thelogicatelier/sylva 1.0.4 → 1.0.10

package/dist/awareness/manifestParsers/javaParsers.js

@@ -0,0 +1,243 @@
+"use strict";
+/**
+ * Java/JVM manifest parsers.
+ * Handles pom.xml and build.gradle(.kts) with regex-based parsing.
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePomXml = parsePomXml;
+exports.parseBuildGradle = parseBuildGradle;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** Known Java frameworks */
+const JAVA_FRAMEWORKS = [
+    {
+        groupArtifact: "org.springframework.boot",
+        frameworkId: "spring-boot",
+        frameworkName: "Spring Boot",
+    },
+    {
+        groupArtifact: "org.springframework",
+        frameworkId: "spring",
+        frameworkName: "Spring Framework",
+    },
+    { groupArtifact: "io.quarkus", frameworkId: "quarkus", frameworkName: "Quarkus" },
+    { groupArtifact: "io.micronaut", frameworkId: "micronaut", frameworkName: "Micronaut" },
+    { groupArtifact: "org.hibernate", frameworkId: "hibernate", frameworkName: "Hibernate" },
+    { groupArtifact: "junit", frameworkId: "junit", frameworkName: "JUnit" },
+    { groupArtifact: "org.junit", frameworkId: "junit5", frameworkName: "JUnit 5" },
+    { groupArtifact: "org.apache.kafka", frameworkId: "kafka", frameworkName: "Apache Kafka" },
+];
+/**
+ * Parse pom.xml (Maven)
+ */
+function parsePomXml(manifest) {
+    const signals = [];
+    const content = fs.readFileSync(manifest.absolutePath, "utf-8");
+    const rootPath = path.dirname(manifest.relativePath) || ".";
+    signals.push({
+        kind: "framework",
+        frameworkId: "java-maven",
+        frameworkName: "Java (Maven)",
+        evidence: {
+            file: manifest.relativePath,
+            reason: "pom.xml found",
+        },
+        scope: { pathRoot: rootPath },
+    });
+    // Extract properties for version resolution
+    const properties = {};
+    const propsMatch = content.match(/<properties>([\s\S]*?)<\/properties>/);
+    if (propsMatch) {
+        const propRegex = /<([a-zA-Z0-9._-]+)>([^<]+)<\/\1>/g;
+        let m;
+        while ((m = propRegex.exec(propsMatch[1])) !== null) {
+            properties[m[1]] = m[2];
+        }
+    }
+    // Extract Java version
+    const javaVersion = properties["java.version"] || properties["maven.compiler.source"];
+    if (javaVersion) {
+        signals.push({
+            kind: "version",
+            frameworkId: "java",
+            frameworkName: "Java",
+            version: { value: javaVersion, certainty: "exact", sourceFile: manifest.relativePath },
+            evidence: {
+                file: manifest.relativePath,
+                reason: "Java version specified in pom.xml properties",
+                excerpt: `java.version = ${javaVersion}`,
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+    // Extract parent (Spring Boot parent, etc.)
+    const parentMatch = content.match(/<parent>[\s\S]*?<groupId>([^<]+)<\/groupId>[\s\S]*?<version>([^<]+)<\/version>[\s\S]*?<\/parent>/);
+    if (parentMatch) {
+        const parentGroup = parentMatch[1];
+        const parentVersion = parentMatch[2];
+        const framework = JAVA_FRAMEWORKS.find((f) => parentGroup.includes(f.groupArtifact));
+        if (framework) {
+            const resolvedVersion = parentVersion.startsWith("${")
+                ? properties[parentVersion.slice(2, -1)]
+                : parentVersion;
+            const versionInfo = resolvedVersion
+                ? { value: resolvedVersion, certainty: "exact", sourceFile: manifest.relativePath }
+                : {
+                    certainty: "ambiguous",
+                    sourceFile: manifest.relativePath,
+                    notes: `Unresolved property: ${parentVersion}`,
+                };
+            signals.push({
+                kind: "framework",
+                frameworkId: framework.frameworkId,
+                frameworkName: framework.frameworkName,
+                version: versionInfo,
+                evidence: {
+                    file: manifest.relativePath,
+                    reason: `Parent POM references ${framework.frameworkName}`,
+                    excerpt: `<groupId>${parentGroup}</groupId> <version>${parentVersion}</version>`,
+                },
+                scope: { pathRoot: rootPath },
+            });
+        }
+    }
+    // Extract dependencies
+    const depRegex = /<dependency>\s*<groupId>([^<]+)<\/groupId>\s*<artifactId>([^<]+)<\/artifactId>(?:\s*<version>([^<]+)<\/version>)?/g;
+    let depMatch;
+    while ((depMatch = depRegex.exec(content)) !== null) {
+        const groupId = depMatch[1];
+        const artifactId = depMatch[2];
+        const version = depMatch[3];
+        const framework = JAVA_FRAMEWORKS.find((f) => groupId.includes(f.groupArtifact));
+        if (framework) {
+            let versionInfo;
+            if (version) {
+                const resolvedVersion = version.startsWith("${")
+                    ? properties[version.slice(2, -1)]
+                    : version;
+                versionInfo = resolvedVersion
+                    ? { value: resolvedVersion, certainty: "exact", sourceFile: manifest.relativePath }
+                    : {
+                        certainty: "ambiguous",
+                        sourceFile: manifest.relativePath,
+                        notes: `Unresolved: ${version}`,
+                    };
+            }
+            else {
+                versionInfo = {
+                    certainty: "unknown",
+                    sourceFile: manifest.relativePath,
+                    notes: "Version managed by parent/BOM",
+                };
+            }
+            signals.push({
+                kind: "framework",
+                frameworkId: framework.frameworkId,
+                frameworkName: framework.frameworkName,
+                version: versionInfo,
+                evidence: {
+                    file: manifest.relativePath,
+                    reason: `Dependency ${groupId}:${artifactId} in pom.xml`,
+                    excerpt: `<groupId>${groupId}</groupId> <artifactId>${artifactId}</artifactId>`,
+                },
+                scope: { pathRoot: rootPath },
+            });
+        }
+    }
+    return signals;
+}
+/**
+ * Parse build.gradle or build.gradle.kts (Gradle)
+ */
+function parseBuildGradle(manifest) {
+    const signals = [];
+    const content = fs.readFileSync(manifest.absolutePath, "utf-8");
+    const rootPath = path.dirname(manifest.relativePath) || ".";
+    const isKts = manifest.filename.endsWith(".kts");
+    signals.push({
+        kind: "framework",
+        frameworkId: "java-gradle",
+        frameworkName: `Java (Gradle${isKts ? " KTS" : ""})`,
+        evidence: {
+            file: manifest.relativePath,
+            reason: `${manifest.filename} found`,
+        },
+        scope: { pathRoot: rootPath },
+    });
+    // Detect Spring Boot plugin
+    const springBootPlugin = content.match(/id\s*[("']org\.springframework\.boot[)"']\s*version\s*[("']([^)"']+)[)"']/);
+    if (springBootPlugin) {
+        signals.push({
+            kind: "framework",
+            frameworkId: "spring-boot",
+            frameworkName: "Spring Boot",
+            version: {
+                value: springBootPlugin[1],
+                certainty: "exact",
+                sourceFile: manifest.relativePath,
+            },
+            evidence: {
+                file: manifest.relativePath,
+                reason: "Spring Boot Gradle plugin found",
+                excerpt: springBootPlugin[0],
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+    // Detect dependencies with versions
+    const depRegex = /(?:implementation|api|compile|testImplementation)\s*[("']([^)"':]+):([^)"':]+):([^)"']+)[)"']/g;
+    let m;
+    while ((m = depRegex.exec(content)) !== null) {
+        const groupId = m[1];
+        const version = m[3];
+        const framework = JAVA_FRAMEWORKS.find((f) => groupId.includes(f.groupArtifact));
+        if (framework) {
+            signals.push({
+                kind: "framework",
+                frameworkId: framework.frameworkId,
+                frameworkName: framework.frameworkName,
+                version: { value: version, certainty: "exact", sourceFile: manifest.relativePath },
+                evidence: {
+                    file: manifest.relativePath,
+                    reason: `Gradle dependency references ${framework.frameworkName}`,
+                    excerpt: m[0],
+                },
+                scope: { pathRoot: rootPath },
+            });
+        }
+    }
+    return signals;
+}

package/dist/awareness/manifestParsers/openclawParser.d.ts

@@ -0,0 +1,6 @@
+/**
+ * OpenClaw manifest parser.
+ * Parses openclaw.json to extract orchestrator configuration.
+ */
+import { Signal, ManifestFile } from "../types";
+export declare function parseOpenclawJson(manifest: ManifestFile): Signal[];

package/dist/awareness/manifestParsers/openclawParser.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * OpenClaw manifest parser.
+ * Parses openclaw.json to extract orchestrator configuration.
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOpenclawJson = parseOpenclawJson;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function parseOpenclawJson(manifest) {
+    const signals = [];
+    const content = fs.readFileSync(manifest.absolutePath, "utf-8");
+    let config;
+    try {
+        config = JSON.parse(content);
+    }
+    catch (error) {
+        console.warn(`⚠️  Could not parse ${manifest.relativePath}: ${error.message}\n` +
+            `   This file appears to be malformed JSON. OpenClaw orchestrator detection is skipped for this file.\n` +
+            `   Fix the JSON syntax to enable OpenClaw orchestrator detection.`);
+        return signals;
+    }
+    const rootPath = path.dirname(manifest.relativePath) || ".";
+    // Primary orchestrator signal
+    signals.push({
+        kind: "orchestrator",
+        frameworkId: "openclaw",
+        frameworkName: "OpenClaw",
+        evidence: {
+            file: manifest.relativePath,
+            reason: "openclaw.json configuration file found",
+            excerpt: content.length > 500 ? content.substring(0, 500) + "..." : content,
+        },
+        scope: { pathRoot: rootPath },
+    });
+    // Extract tool signals
+    const tools = config.tools;
+    if (tools && typeof tools === "object") {
+        for (const [toolName, toolConfig] of Object.entries(tools)) {
+            signals.push({
+                kind: "tooling",
+                frameworkId: `openclaw-tool-${toolName}`,
+                frameworkName: `OpenClaw Tool: ${toolName}`,
+                evidence: {
+                    file: manifest.relativePath,
+                    reason: `Tool '${toolName}' configured in openclaw.json`,
+                    excerpt: JSON.stringify(toolConfig, null, 2).substring(0, 200),
+                },
+                scope: { pathRoot: rootPath },
+            });
+        }
+    }
+    // Extract channel signals
+    const channels = config.channels;
+    if (channels && typeof channels === "object") {
+        for (const [channelName] of Object.entries(channels)) {
+            signals.push({
+                kind: "tooling",
+                frameworkId: `openclaw-channel-${channelName}`,
+                frameworkName: `OpenClaw Channel: ${channelName}`,
+                evidence: {
+                    file: manifest.relativePath,
+                    reason: `Channel '${channelName}' configured in openclaw.json`,
+                },
+                scope: { pathRoot: rootPath },
+            });
+        }
+    }
+    return signals;
+}

package/dist/awareness/manifestParsers/packageJsonParser.d.ts

@@ -0,0 +1,7 @@
+/**
+ * package.json parser.
+ * Detects Node.js/JS/TS frameworks from dependencies, scripts, and metadata.
+ * Handles React, Angular, Vue, Next.js, Express, NestJS, and more.
+ */
+import { Signal, ManifestFile } from "../types";
+export declare function parsePackageJson(manifest: ManifestFile): Signal[];

package/dist/awareness/manifestParsers/packageJsonParser.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * package.json parser.
+ * Detects Node.js/JS/TS frameworks from dependencies, scripts, and metadata.
+ * Handles React, Angular, Vue, Next.js, Express, NestJS, and more.
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePackageJson = parsePackageJson;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** Framework detection rules: dep name patterns → framework info */
+const FRAMEWORK_DETECTION_RULES = [
+    { depPattern: "@angular/core", frameworkId: "angular", frameworkName: "Angular" },
+    { depPattern: "react", frameworkId: "react", frameworkName: "React" },
+    { depPattern: "react-dom", frameworkId: "react-dom", frameworkName: "React DOM" },
+    { depPattern: "next", frameworkId: "nextjs", frameworkName: "Next.js" },
+    { depPattern: "vue", frameworkId: "vue", frameworkName: "Vue.js" },
+    { depPattern: "nuxt", frameworkId: "nuxt", frameworkName: "Nuxt" },
+    { depPattern: "@sveltejs/kit", frameworkId: "sveltekit", frameworkName: "SvelteKit" },
+    { depPattern: "svelte", frameworkId: "svelte", frameworkName: "Svelte" },
+    { depPattern: "express", frameworkId: "express", frameworkName: "Express" },
+    { depPattern: "@nestjs/core", frameworkId: "nestjs", frameworkName: "NestJS" },
+    { depPattern: "fastify", frameworkId: "fastify", frameworkName: "Fastify" },
+    { depPattern: "koa", frameworkId: "koa", frameworkName: "Koa" },
+    { depPattern: "typescript", frameworkId: "typescript", frameworkName: "TypeScript" },
+    { depPattern: "@ax-llm/ax", frameworkId: "ax-llm", frameworkName: "Ax-LLM" },
+    { depPattern: "electron", frameworkId: "electron", frameworkName: "Electron" },
+    { depPattern: "react-native", frameworkId: "react-native", frameworkName: "React Native" },
+    { depPattern: "tailwindcss", frameworkId: "tailwindcss", frameworkName: "Tailwind CSS" },
+    { depPattern: "vite", frameworkId: "vite", frameworkName: "Vite" },
+    { depPattern: "webpack", frameworkId: "webpack", frameworkName: "Webpack" },
+    { depPattern: "esbuild", frameworkId: "esbuild", frameworkName: "esbuild" },
+];
+/**
+ * Determine version certainty from a semver-like string.
+ */
+function parseVersionCertainty(versionStr, sourceFile, depName, lockfileAvailable) {
+    if (!versionStr) {
+        return { certainty: "unknown", sourceFile, notes: `No version specified for ${depName}` };
+    }
+    // Exact pinned version (no ^, ~, >=, etc.)
+    if (/^\d+\.\d+\.\d+/.test(versionStr) && !/^[~^>=<]/.test(versionStr)) {
+        return { value: versionStr, certainty: "exact", sourceFile };
+    }
+    // Range-based version
+    const cleanVersion = versionStr.replace(/^[~^>=<]+/, "");
+    if (lockfileAvailable) {
+        return {
+            value: cleanVersion,
+            certainty: "ambiguous",
+            sourceFile,
+            notes: `Range '${versionStr}' in package.json; lockfile exists but not parsed for exact resolution`,
+        };
+    }
+    return {
+        value: cleanVersion,
+        certainty: "ambiguous",
+        sourceFile,
+        notes: `Range '${versionStr}' without lockfile resolution`,
+    };
+}
+function parsePackageJson(manifest) {
+    const signals = [];
+    const content = fs.readFileSync(manifest.absolutePath, "utf-8");
+    let pkg;
+    try {
+        pkg = JSON.parse(content);
+    }
+    catch (error) {
+        console.warn(`⚠️  Could not parse ${manifest.relativePath}: ${error.message}\n` +
+            `   This package.json has malformed JSON. Node.js framework detection is skipped for this file.`);
+        return signals;
+    }
+    const rootPath = path.dirname(manifest.relativePath) || ".";
+    const deps = (pkg.dependencies || {});
+    const devDeps = (pkg.devDependencies || {});
+    const peerDeps = (pkg.peerDependencies || {});
+    const allDeps = { ...peerDeps, ...devDeps, ...deps }; // deps last for precedence
+    // Check if a lockfile exists nearby
+    const manifestDir = path.dirname(manifest.absolutePath);
+    const hasLockfile = fs.existsSync(path.join(manifestDir, "package-lock.json")) ||
+        fs.existsSync(path.join(manifestDir, "yarn.lock")) ||
+        fs.existsSync(path.join(manifestDir, "pnpm-lock.yaml"));
+    // Emit a Node.js/npm signal for the package itself
+    signals.push({
+        kind: "framework",
+        frameworkId: "nodejs",
+        frameworkName: "Node.js",
+        evidence: {
+            file: manifest.relativePath,
+            reason: "package.json found",
+        },
+        scope: { pathRoot: rootPath },
+    });
+    // Detect frameworks from dependencies
+    for (const rule of FRAMEWORK_DETECTION_RULES) {
+        const depName = typeof rule.depPattern === "string" ? rule.depPattern : undefined;
+        let matchedDep;
+        let matchedVersion;
+        if (depName && allDeps[depName]) {
+            matchedDep = depName;
+            matchedVersion = allDeps[depName];
+        }
+        else if (rule.depPattern instanceof RegExp) {
+            for (const [dep, ver] of Object.entries(allDeps)) {
+                if (rule.depPattern.test(dep)) {
+                    matchedDep = dep;
+                    matchedVersion = ver;
+                    break;
+                }
+            }
+        }
+        if (matchedDep && matchedVersion !== undefined) {
+            const versionInfo = parseVersionCertainty(matchedVersion, manifest.relativePath, matchedDep, hasLockfile);
+            signals.push({
+                kind: "framework",
+                frameworkId: rule.frameworkId,
+                frameworkName: rule.frameworkName,
+                version: versionInfo,
+                evidence: {
+                    file: manifest.relativePath,
+                    reason: `Dependency '${matchedDep}' found in package.json`,
+                    excerpt: `"${matchedDep}": "${matchedVersion}"`,
+                },
+                scope: { pathRoot: rootPath },
+            });
+        }
+    }
+    // Detect Angular specifically from multiple @angular/* deps
+    const angularDeps = Object.entries(allDeps).filter(([dep]) => dep.startsWith("@angular/"));
+    if (angularDeps.length > 1) {
+        // Angular workspace confirmed (multiple @angular packages)
+        const coreDep = angularDeps.find(([dep]) => dep === "@angular/core");
+        if (coreDep) {
+            const versionInfo = parseVersionCertainty(coreDep[1], manifest.relativePath, "@angular/core", hasLockfile);
+            // Only add if not already added
+            const alreadyAdded = signals.some((s) => s.frameworkId === "angular");
+            if (!alreadyAdded) {
+                signals.push({
+                    kind: "framework",
+                    frameworkId: "angular",
+                    frameworkName: "Angular",
+                    version: versionInfo,
+                    evidence: {
+                        file: manifest.relativePath,
+                        reason: `${angularDeps.length} @angular/* dependencies found`,
+                        excerpt: angularDeps
+                            .slice(0, 5)
+                            .map(([d, v]) => `"${d}": "${v}"`)
+                            .join(", "),
+                    },
+                    scope: { pathRoot: rootPath },
+                });
+            }
+        }
+    }
+    // Detect build tools from scripts
+    const scripts = (pkg.scripts || {});
+    if (scripts.build || scripts.start || scripts.dev) {
+        signals.push({
+            kind: "entrypoint",
+            frameworkId: "npm-scripts",
+            frameworkName: "npm scripts",
+            evidence: {
+                file: manifest.relativePath,
+                reason: "Build/start/dev scripts found in package.json",
+                excerpt: Object.entries(scripts)
+                    .slice(0, 5)
+                    .map(([k, v]) => `"${k}": "${v}"`)
+                    .join(", "),
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+    return signals;
+}

package/dist/awareness/manifestParsers/pythonParsers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Python manifest parsers.
+ * Handles requirements.txt, pyproject.toml, poetry.lock, Pipfile, Pipfile.lock, setup.cfg.
+ */
+import { Signal, ManifestFile } from "../types";
+/**
+ * Parse requirements.txt
+ */
+export declare function parseRequirementsTxt(manifest: ManifestFile): Signal[];
+/**
+ * Parse pyproject.toml (basic TOML parsing with regex — no external dependency)
+ */
+export declare function parsePyprojectToml(manifest: ManifestFile): Signal[];
+/**
+ * Parse Pipfile (basic TOML-like parsing)
+ */
+export declare function parsePipfile(manifest: ManifestFile): Signal[];
+/**
+ * Parse setup.cfg (ini-like)
+ */
+export declare function parseSetupCfg(manifest: ManifestFile): Signal[];