@thelogicatelier/sylva 1.0.4 → 1.0.10

package/dist/awareness/manifestParsers/pythonParsers.js

@@ -0,0 +1,344 @@
+"use strict";
+/**
+ * Python manifest parsers.
+ * Handles requirements.txt, pyproject.toml, poetry.lock, Pipfile, Pipfile.lock, setup.cfg.
+ */
+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.parseRequirementsTxt = parseRequirementsTxt;
+exports.parsePyprojectToml = parsePyprojectToml;
+exports.parsePipfile = parsePipfile;
+exports.parseSetupCfg = parseSetupCfg;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** Known Python frameworks and their detection patterns */
+const PYTHON_FRAMEWORKS = [
+    { pkg: "django", frameworkId: "django", frameworkName: "Django" },
+    { pkg: "flask", frameworkId: "flask", frameworkName: "Flask" },
+    { pkg: "fastapi", frameworkId: "fastapi", frameworkName: "FastAPI" },
+    { pkg: "uvicorn", frameworkId: "uvicorn", frameworkName: "Uvicorn" },
+    { pkg: "starlette", frameworkId: "starlette", frameworkName: "Starlette" },
+    { pkg: "celery", frameworkId: "celery", frameworkName: "Celery" },
+    { pkg: "sqlalchemy", frameworkId: "sqlalchemy", frameworkName: "SQLAlchemy" },
+    { pkg: "pandas", frameworkId: "pandas", frameworkName: "Pandas" },
+    { pkg: "numpy", frameworkId: "numpy", frameworkName: "NumPy" },
+    { pkg: "tensorflow", frameworkId: "tensorflow", frameworkName: "TensorFlow" },
+    { pkg: "torch", frameworkId: "pytorch", frameworkName: "PyTorch" },
+    { pkg: "scikit-learn", frameworkId: "scikit-learn", frameworkName: "scikit-learn" },
+    { pkg: "pytest", frameworkId: "pytest", frameworkName: "pytest" },
+    { pkg: "gunicorn", frameworkId: "gunicorn", frameworkName: "Gunicorn" },
+];
+function parsePythonVersion(versionSpec, sourceFile, pkgName) {
+    if (!versionSpec || versionSpec.trim() === "") {
+        return { certainty: "unknown", sourceFile, notes: `No version for ${pkgName}` };
+    }
+    // Exact pin: ==X.Y.Z
+    const exactMatch = versionSpec.match(/^==\s*(\S+)/);
+    if (exactMatch) {
+        return { value: exactMatch[1], certainty: "exact", sourceFile };
+    }
+    // Range-based (>=, <=, ~=, !=, etc.)
+    const rangeMatch = versionSpec.match(/[><=~!]+\s*(\S+)/);
+    if (rangeMatch) {
+        return {
+            value: rangeMatch[1],
+            certainty: "ambiguous",
+            sourceFile,
+            notes: `Version constraint '${versionSpec.trim()}' is a range`,
+        };
+    }
+    return { certainty: "unknown", sourceFile, notes: `Unparseable version: ${versionSpec}` };
+}
+/**
+ * Parse requirements.txt
+ */
+function parseRequirementsTxt(manifest) {
+    const signals = [];
+    const content = fs.readFileSync(manifest.absolutePath, "utf-8");
+    const rootPath = path.dirname(manifest.relativePath) || ".";
+    // Python signal
+    signals.push({
+        kind: "framework",
+        frameworkId: "python",
+        frameworkName: "Python",
+        evidence: {
+            file: manifest.relativePath,
+            reason: "requirements.txt found",
+        },
+        scope: { pathRoot: rootPath },
+    });
+    const lines = content.split("\n");
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("-"))
+            continue;
+        // Parse package==version or package>=version etc.
+        const match = trimmed.match(/^([a-zA-Z0-9_.-]+)\s*([><=~!]+.*)?$/);
+        if (!match)
+            continue;
+        const pkgName = match[1].toLowerCase();
+        const versionSpec = match[2] || "";
+        const framework = PYTHON_FRAMEWORKS.find((f) => f.pkg === pkgName);
+        if (framework) {
+            const versionInfo = parsePythonVersion(versionSpec, manifest.relativePath, pkgName);
+            signals.push({
+                kind: "framework",
+                frameworkId: framework.frameworkId,
+                frameworkName: framework.frameworkName,
+                version: versionInfo,
+                evidence: {
+                    file: manifest.relativePath,
+                    reason: `Python package '${pkgName}' found in requirements.txt`,
+                    excerpt: trimmed,
+                },
+                scope: { pathRoot: rootPath },
+            });
+        }
+    }
+    return signals;
+}
+/**
+ * Parse pyproject.toml (basic TOML parsing with regex — no external dependency)
+ */
+function parsePyprojectToml(manifest) {
+    const signals = [];
+    const content = fs.readFileSync(manifest.absolutePath, "utf-8");
+    const rootPath = path.dirname(manifest.relativePath) || ".";
+    signals.push({
+        kind: "framework",
+        frameworkId: "python",
+        frameworkName: "Python",
+        evidence: {
+            file: manifest.relativePath,
+            reason: "pyproject.toml found",
+        },
+        scope: { pathRoot: rootPath },
+    });
+    // Detect build system
+    if (content.includes("[tool.poetry]")) {
+        signals.push({
+            kind: "tooling",
+            frameworkId: "poetry",
+            frameworkName: "Poetry",
+            evidence: {
+                file: manifest.relativePath,
+                reason: "[tool.poetry] section found in pyproject.toml",
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+    // Extract dependencies from [project.dependencies] or [tool.poetry.dependencies]
+    // Simple regex-based extraction
+    const depPatterns = [
+        /\[(?:project\.dependencies|tool\.poetry\.dependencies)\]([\s\S]*?)(?:\n\[|$)/,
+    ];
+    for (const pattern of depPatterns) {
+        const match = content.match(pattern);
+        if (!match)
+            continue;
+        const depsSection = match[1];
+        const depLines = depsSection.split("\n");
+        for (const depLine of depLines) {
+            const trimmed = depLine.trim();
+            if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("["))
+                continue;
+            // Match: package = "version" or package = {version = "..."}
+            const simpleMatch = trimmed.match(/^([a-zA-Z0-9_.-]+)\s*=\s*"([^"]*)"/);
+            if (simpleMatch) {
+                const pkgName = simpleMatch[1].toLowerCase();
+                const versionSpec = simpleMatch[2];
+                const framework = PYTHON_FRAMEWORKS.find((f) => f.pkg === pkgName);
+                if (framework) {
+                    const isPinned = /^\d+\.\d+/.test(versionSpec) && !/[><=~^]/.test(versionSpec);
+                    const versionInfo = isPinned
+                        ? { value: versionSpec, certainty: "exact", sourceFile: manifest.relativePath }
+                        : {
+                            value: versionSpec.replace(/^[><=~^]+/, ""),
+                            certainty: "ambiguous",
+                            sourceFile: manifest.relativePath,
+                            notes: `Constraint '${versionSpec}' in pyproject.toml`,
+                        };
+                    signals.push({
+                        kind: "framework",
+                        frameworkId: framework.frameworkId,
+                        frameworkName: framework.frameworkName,
+                        version: versionInfo,
+                        evidence: {
+                            file: manifest.relativePath,
+                            reason: `Python package '${pkgName}' found in pyproject.toml`,
+                            excerpt: trimmed,
+                        },
+                        scope: { pathRoot: rootPath },
+                    });
+                }
+            }
+        }
+    }
+    // Check for python version requirement
+    const pythonVersionMatch = content.match(/requires-python\s*=\s*"([^"]+)"/);
+    if (pythonVersionMatch) {
+        const spec = pythonVersionMatch[1];
+        const isExact = /^\d+\.\d+/.test(spec) && !/[><=~^]/.test(spec);
+        signals.push({
+            kind: "version",
+            frameworkId: "python",
+            frameworkName: "Python",
+            version: {
+                value: spec.replace(/^[><=~^]+/, ""),
+                certainty: isExact ? "exact" : "ambiguous",
+                sourceFile: manifest.relativePath,
+                notes: isExact ? undefined : `Constraint '${spec}'`,
+            },
+            evidence: {
+                file: manifest.relativePath,
+                reason: "Python version requirement in pyproject.toml",
+                excerpt: `requires-python = "${spec}"`,
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+    return signals;
+}
+/**
+ * Parse Pipfile (basic TOML-like parsing)
+ */
+function parsePipfile(manifest) {
+    const signals = [];
+    const content = fs.readFileSync(manifest.absolutePath, "utf-8");
+    const rootPath = path.dirname(manifest.relativePath) || ".";
+    signals.push({
+        kind: "framework",
+        frameworkId: "python",
+        frameworkName: "Python",
+        evidence: {
+            file: manifest.relativePath,
+            reason: "Pipfile found (Pipenv project)",
+        },
+        scope: { pathRoot: rootPath },
+    });
+    signals.push({
+        kind: "tooling",
+        frameworkId: "pipenv",
+        frameworkName: "Pipenv",
+        evidence: {
+            file: manifest.relativePath,
+            reason: "Pipfile found",
+        },
+        scope: { pathRoot: rootPath },
+    });
+    // Extract packages section
+    const packagesMatch = content.match(/\[packages\]([\s\S]*?)(?:\n\[|$)/);
+    if (packagesMatch) {
+        const lines = packagesMatch[1].split("\n");
+        for (const line of lines) {
+            const match = line.trim().match(/^([a-zA-Z0-9_.-]+)\s*=\s*"([^"]*)"/);
+            if (match) {
+                const pkgName = match[1].toLowerCase();
+                const framework = PYTHON_FRAMEWORKS.find((f) => f.pkg === pkgName);
+                if (framework) {
+                    const versionSpec = match[2];
+                    const isExact = versionSpec === "*" ? false : /^\d+\.\d+/.test(versionSpec);
+                    signals.push({
+                        kind: "framework",
+                        frameworkId: framework.frameworkId,
+                        frameworkName: framework.frameworkName,
+                        version: isExact
+                            ? { value: versionSpec, certainty: "exact", sourceFile: manifest.relativePath }
+                            : {
+                                certainty: versionSpec === "*" ? "unknown" : "ambiguous",
+                                sourceFile: manifest.relativePath,
+                            },
+                        evidence: {
+                            file: manifest.relativePath,
+                            reason: `Python package '${pkgName}' found in Pipfile`,
+                            excerpt: line.trim(),
+                        },
+                        scope: { pathRoot: rootPath },
+                    });
+                }
+            }
+        }
+    }
+    return signals;
+}
+/**
+ * Parse setup.cfg (ini-like)
+ */
+function parseSetupCfg(manifest) {
+    const signals = [];
+    const content = fs.readFileSync(manifest.absolutePath, "utf-8");
+    const rootPath = path.dirname(manifest.relativePath) || ".";
+    signals.push({
+        kind: "framework",
+        frameworkId: "python",
+        frameworkName: "Python",
+        evidence: {
+            file: manifest.relativePath,
+            reason: "setup.cfg found (Python setuptools project)",
+        },
+        scope: { pathRoot: rootPath },
+    });
+    // Extract install_requires
+    const installRequiresMatch = content.match(/install_requires\s*=\s*([\s\S]*?)(?:\n\S|\n\[|$)/);
+    if (installRequiresMatch) {
+        const lines = installRequiresMatch[1].split("\n");
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const match = trimmed.match(/^([a-zA-Z0-9_.-]+)\s*([><=~!]+.*)?$/);
+            if (match) {
+                const pkgName = match[1].toLowerCase();
+                const framework = PYTHON_FRAMEWORKS.find((f) => f.pkg === pkgName);
+                if (framework) {
+                    const versionInfo = parsePythonVersion(match[2] || "", manifest.relativePath, pkgName);
+                    signals.push({
+                        kind: "framework",
+                        frameworkId: framework.frameworkId,
+                        frameworkName: framework.frameworkName,
+                        version: versionInfo,
+                        evidence: {
+                            file: manifest.relativePath,
+                            reason: `Python package '${pkgName}' found in setup.cfg`,
+                            excerpt: trimmed,
+                        },
+                        scope: { pathRoot: rootPath },
+                    });
+                }
+            }
+        }
+    }
+    return signals;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Rust manifest parser.
+ * Handles Cargo.toml files.
+ */
+import { Signal, ManifestFile } from "../types";
+/**
+ * Parse Cargo.toml
+ */
+export declare function parseCargoToml(manifest: ManifestFile): Signal[];

package/dist/awareness/manifestParsers/rustParsers.js

@@ -0,0 +1,153 @@
+"use strict";
+/**
+ * Rust manifest parser.
+ * Handles Cargo.toml files.
+ */
+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.parseCargoToml = parseCargoToml;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** Known Rust frameworks/libraries */
+const RUST_FRAMEWORKS = [
+    { crate: "actix-web", frameworkId: "actix-web", frameworkName: "Actix Web" },
+    { crate: "rocket", frameworkId: "rocket", frameworkName: "Rocket" },
+    { crate: "axum", frameworkId: "axum", frameworkName: "Axum" },
+    { crate: "tokio", frameworkId: "tokio", frameworkName: "Tokio" },
+    { crate: "serde", frameworkId: "serde", frameworkName: "Serde" },
+    { crate: "diesel", frameworkId: "diesel", frameworkName: "Diesel" },
+    { crate: "sqlx", frameworkId: "sqlx", frameworkName: "SQLx" },
+    { crate: "warp", frameworkId: "warp", frameworkName: "Warp" },
+];
+/**
+ * Parse Cargo.toml
+ */
+function parseCargoToml(manifest) {
+    const signals = [];
+    const content = fs.readFileSync(manifest.absolutePath, "utf-8");
+    const rootPath = path.dirname(manifest.relativePath) || ".";
+    signals.push({
+        kind: "framework",
+        frameworkId: "rust",
+        frameworkName: "Rust",
+        evidence: {
+            file: manifest.relativePath,
+            reason: "Cargo.toml found",
+        },
+        scope: { pathRoot: rootPath },
+    });
+    // Extract Rust edition
+    const editionMatch = content.match(/edition\s*=\s*"(\d{4})"/);
+    if (editionMatch) {
+        signals.push({
+            kind: "version",
+            frameworkId: "rust",
+            frameworkName: "Rust",
+            version: {
+                value: `edition ${editionMatch[1]}`,
+                certainty: "exact",
+                sourceFile: manifest.relativePath,
+            },
+            evidence: {
+                file: manifest.relativePath,
+                reason: "Rust edition specified in Cargo.toml",
+                excerpt: `edition = "${editionMatch[1]}"`,
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+    // Extract dependencies
+    const depSections = [
+        content.match(/\[dependencies\]([\s\S]*?)(?:\n\[|$)/),
+        content.match(/\[dev-dependencies\]([\s\S]*?)(?:\n\[|$)/),
+    ];
+    for (const sectionMatch of depSections) {
+        if (!sectionMatch)
+            continue;
+        const section = sectionMatch[1];
+        const lines = section.split("\n");
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("["))
+                continue;
+            // Match: crate = "version" or crate = { version = "..." }
+            let crateName;
+            let versionStr;
+            const simpleMatch = trimmed.match(/^([a-zA-Z0-9_-]+)\s*=\s*"([^"]*)"/);
+            if (simpleMatch) {
+                crateName = simpleMatch[1];
+                versionStr = simpleMatch[2];
+            }
+            const tableMatch = trimmed.match(/^([a-zA-Z0-9_-]+)\s*=\s*\{.*version\s*=\s*"([^"]*)"/);
+            if (tableMatch) {
+                crateName = tableMatch[1];
+                versionStr = tableMatch[2];
+            }
+            if (!crateName)
+                continue;
+            const framework = RUST_FRAMEWORKS.find((f) => f.crate === crateName);
+            if (framework) {
+                let versionInfo;
+                if (versionStr) {
+                    const isPinned = /^\d+\.\d+\.\d+$/.test(versionStr);
+                    versionInfo = isPinned
+                        ? { value: versionStr, certainty: "exact", sourceFile: manifest.relativePath }
+                        : {
+                            value: versionStr,
+                            certainty: "ambiguous",
+                            sourceFile: manifest.relativePath,
+                            notes: `Semver range: ${versionStr}`,
+                        };
+                }
+                else {
+                    versionInfo = { certainty: "unknown", sourceFile: manifest.relativePath };
+                }
+                signals.push({
+                    kind: "framework",
+                    frameworkId: framework.frameworkId,
+                    frameworkName: framework.frameworkName,
+                    version: versionInfo,
+                    evidence: {
+                        file: manifest.relativePath,
+                        reason: `Rust crate '${crateName}' found in Cargo.toml`,
+                        excerpt: trimmed,
+                    },
+                    scope: { pathRoot: rootPath },
+                });
+            }
+        }
+    }
+    return signals;
+}

package/dist/awareness/manifestScanner.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Full-repo manifest scanner.
+ * Recursively walks the entire repository to discover framework manifest files,
+ * regardless of nesting depth. Handles monorepos and nested subprojects.
+ */
+import { ManifestFile } from "./types";
+/**
+ * Recursively scan a repository for manifest files.
+ * Returns all discovered manifest files with metadata.
+ */
+export declare function scanManifests(repoPath: string): ManifestFile[];