@thelogicatelier/sylva 1.0.9 → 1.0.10

package/dist/awareness/manifestParsers/dotnetParsers.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * .NET manifest parsers.
+ * Handles *.csproj files and global.json.
+ */
+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.parseCsproj = parseCsproj;
+exports.parseGlobalJson = parseGlobalJson;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Parse a .csproj file (MSBuild XML format)
+ */
+function parseCsproj(manifest) {
+    const signals = [];
+    const content = fs.readFileSync(manifest.absolutePath, "utf-8");
+    const rootPath = path.dirname(manifest.relativePath) || ".";
+    signals.push({
+        kind: "framework",
+        frameworkId: "dotnet",
+        frameworkName: ".NET",
+        evidence: {
+            file: manifest.relativePath,
+            reason: `${manifest.filename} project file found`,
+        },
+        scope: { pathRoot: rootPath },
+    });
+    // Extract TargetFramework
+    const tfMatch = content.match(/<TargetFramework>([^<]+)<\/TargetFramework>/);
+    if (tfMatch) {
+        signals.push({
+            kind: "version",
+            frameworkId: "dotnet",
+            frameworkName: ".NET",
+            version: { value: tfMatch[1], certainty: "exact", sourceFile: manifest.relativePath },
+            evidence: {
+                file: manifest.relativePath,
+                reason: "TargetFramework specified in csproj",
+                excerpt: `<TargetFramework>${tfMatch[1]}</TargetFramework>`,
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+    // Extract PackageReference versions
+    const pkgRefRegex = /<PackageReference\s+Include="([^"]+)"\s+Version="([^"]+)"/g;
+    let m;
+    while ((m = pkgRefRegex.exec(content)) !== null) {
+        const pkgName = m[1];
+        const version = m[2];
+        const isPinned = /^\d+\.\d+/.test(version) && !/[*[\]]/.test(version);
+        const versionInfo = isPinned
+            ? { value: version, certainty: "exact", sourceFile: manifest.relativePath }
+            : {
+                value: version,
+                certainty: "ambiguous",
+                sourceFile: manifest.relativePath,
+                notes: `Version range: ${version}`,
+            };
+        // Check for known .NET frameworks
+        let frameworkId = `nuget-${pkgName.toLowerCase()}`;
+        let frameworkName = pkgName;
+        if (pkgName.startsWith("Microsoft.AspNetCore") || pkgName.startsWith("Microsoft.Extensions")) {
+            frameworkId = "aspnet-core";
+            frameworkName = "ASP.NET Core";
+        }
+        else if (pkgName.startsWith("Microsoft.EntityFrameworkCore")) {
+            frameworkId = "ef-core";
+            frameworkName = "Entity Framework Core";
+        }
+        signals.push({
+            kind: "framework",
+            frameworkId,
+            frameworkName,
+            version: versionInfo,
+            evidence: {
+                file: manifest.relativePath,
+                reason: `NuGet package '${pkgName}' referenced in csproj`,
+                excerpt: m[0],
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+    return signals;
+}
+/**
+ * Parse global.json (.NET SDK version pinning)
+ */
+function parseGlobalJson(manifest) {
+    const signals = [];
+    const content = fs.readFileSync(manifest.absolutePath, "utf-8");
+    const rootPath = path.dirname(manifest.relativePath) || ".";
+    try {
+        const config = JSON.parse(content);
+        if (config.sdk?.version) {
+            signals.push({
+                kind: "version",
+                frameworkId: "dotnet-sdk",
+                frameworkName: ".NET SDK",
+                version: {
+                    value: config.sdk.version,
+                    certainty: "exact",
+                    sourceFile: manifest.relativePath,
+                },
+                evidence: {
+                    file: manifest.relativePath,
+                    reason: ".NET SDK version pinned in global.json",
+                    excerpt: `"version": "${config.sdk.version}"`,
+                },
+                scope: { pathRoot: rootPath },
+            });
+        }
+    }
+    catch (error) {
+        console.warn(`⚠️  Could not parse ${manifest.relativePath}: ${error.message}\n` +
+            `   .NET SDK version detection skipped for this file. Fix the JSON syntax to enable it.`);
+    }
+    return signals;
+}

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

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

package/dist/awareness/manifestParsers/goParsers.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * Go manifest parser.
+ * Handles go.mod 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.parseGoMod = parseGoMod;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** Known Go frameworks/libraries */
+const GO_FRAMEWORKS = [
+    { module: "github.com/gin-gonic/gin", frameworkId: "gin", frameworkName: "Gin" },
+    { module: "github.com/labstack/echo", frameworkId: "echo", frameworkName: "Echo" },
+    { module: "github.com/gofiber/fiber", frameworkId: "fiber", frameworkName: "Fiber" },
+    { module: "github.com/gorilla/mux", frameworkId: "gorilla-mux", frameworkName: "Gorilla Mux" },
+    { module: "gorm.io/gorm", frameworkId: "gorm", frameworkName: "GORM" },
+    { module: "github.com/stretchr/testify", frameworkId: "testify", frameworkName: "Testify" },
+    { module: "google.golang.org/grpc", frameworkId: "grpc-go", frameworkName: "gRPC-Go" },
+];
+/**
+ * Parse go.mod
+ */
+function parseGoMod(manifest) {
+    const signals = [];
+    const content = fs.readFileSync(manifest.absolutePath, "utf-8");
+    const rootPath = path.dirname(manifest.relativePath) || ".";
+    // Extract Go version
+    const goVersionMatch = content.match(/^go\s+(\S+)/m);
+    if (goVersionMatch) {
+        signals.push({
+            kind: "framework",
+            frameworkId: "go",
+            frameworkName: "Go",
+            version: { value: goVersionMatch[1], certainty: "exact", sourceFile: manifest.relativePath },
+            evidence: {
+                file: manifest.relativePath,
+                reason: "Go version specified in go.mod",
+                excerpt: `go ${goVersionMatch[1]}`,
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+    else {
+        signals.push({
+            kind: "framework",
+            frameworkId: "go",
+            frameworkName: "Go",
+            evidence: {
+                file: manifest.relativePath,
+                reason: "go.mod found",
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+    // Extract module name
+    const moduleMatch = content.match(/^module\s+(\S+)/m);
+    if (moduleMatch) {
+        signals.push({
+            kind: "entrypoint",
+            frameworkId: "go-module",
+            frameworkName: "Go Module",
+            evidence: {
+                file: manifest.relativePath,
+                reason: `Go module: ${moduleMatch[1]}`,
+                excerpt: `module ${moduleMatch[1]}`,
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+    // Extract require blocks
+    const requireBlock = content.match(/require\s*\(([\s\S]*?)\)/);
+    const requireLines = [];
+    if (requireBlock) {
+        requireLines.push(...requireBlock[1].split("\n"));
+    }
+    // Also handle single-line requires
+    const singleRequires = content.match(/^require\s+(\S+)\s+(\S+)/gm);
+    if (singleRequires) {
+        requireLines.push(...singleRequires);
+    }
+    for (const line of requireLines) {
+        const match = line.trim().match(/^(\S+)\s+(v\S+)/);
+        if (!match)
+            continue;
+        const modulePath = match[1];
+        const version = match[2];
+        const framework = GO_FRAMEWORKS.find((f) => modulePath.startsWith(f.module));
+        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: `Go dependency '${modulePath}' found in go.mod`,
+                    excerpt: `${modulePath} ${version}`,
+                },
+                scope: { pathRoot: rootPath },
+            });
+        }
+    }
+    return signals;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Manifest parser dispatcher.
+ * Routes discovered manifest files to the appropriate parser based on filename.
+ */
+import { Signal, ManifestFile } from "../types";
+/**
+ * Parse a single manifest file and return signals.
+ */
+export declare function parseManifest(manifest: ManifestFile): Signal[];
+/**
+ * Parse all discovered manifests and return combined signals.
+ */
+export declare function parseAllManifests(manifests: ManifestFile[]): Signal[];

package/dist/awareness/manifestParsers/index.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Manifest parser dispatcher.
+ * Routes discovered manifest files to the appropriate parser based on filename.
+ */
+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.parseManifest = parseManifest;
+exports.parseAllManifests = parseAllManifests;
+const openclawParser_1 = require("./openclawParser");
+const packageJsonParser_1 = require("./packageJsonParser");
+const pythonParsers_1 = require("./pythonParsers");
+const javaParsers_1 = require("./javaParsers");
+const dotnetParsers_1 = require("./dotnetParsers");
+const goParsers_1 = require("./goParsers");
+const rustParsers_1 = require("./rustParsers");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Parse angular.json to detect Angular workspace structure.
+ */
+function parseAngularJson(manifest) {
+    const signals = [];
+    const content = fs.readFileSync(manifest.absolutePath, "utf-8");
+    const rootPath = path.dirname(manifest.relativePath) || ".";
+    try {
+        const config = JSON.parse(content);
+        const projects = config.projects ? Object.keys(config.projects) : [];
+        signals.push({
+            kind: "framework",
+            frameworkId: "angular",
+            frameworkName: "Angular",
+            evidence: {
+                file: manifest.relativePath,
+                reason: `angular.json workspace found with ${projects.length} project(s): ${projects.join(", ")}`,
+                excerpt: projects.length > 0 ? `Projects: ${projects.slice(0, 5).join(", ")}` : undefined,
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+    catch (error) {
+        // Invalid JSON — still record the Angular workspace with a note
+        console.warn(`⚠️  Could not parse ${manifest.relativePath} as JSON: ${error.message}\n` +
+            `   Angular workspace detected but project details are unavailable. This is non-fatal.`);
+        signals.push({
+            kind: "framework",
+            frameworkId: "angular",
+            frameworkName: "Angular",
+            evidence: {
+                file: manifest.relativePath,
+                reason: "angular.json found but JSON is malformed — workspace detected without project details",
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+    return signals;
+}
+/**
+ * Parse Dockerfile for runtime hints
+ */
+function parseDockerfile(manifest) {
+    const signals = [];
+    const content = fs.readFileSync(manifest.absolutePath, "utf-8");
+    const rootPath = path.dirname(manifest.relativePath) || ".";
+    // Extract FROM base images
+    const fromMatches = content.match(/^FROM\s+(\S+)/gm);
+    if (fromMatches) {
+        for (const fromLine of fromMatches) {
+            const image = fromLine.replace(/^FROM\s+/, "").trim();
+            signals.push({
+                kind: "tooling",
+                frameworkId: "docker",
+                frameworkName: "Docker",
+                evidence: {
+                    file: manifest.relativePath,
+                    reason: `Docker base image: ${image}`,
+                    excerpt: fromLine,
+                },
+                scope: { pathRoot: rootPath },
+            });
+        }
+    }
+    return signals;
+}
+/**
+ * Parse a single manifest file and return signals.
+ */
+function parseManifest(manifest) {
+    try {
+        const filename = manifest.filename;
+        // Exact filename matches
+        switch (filename) {
+            case "openclaw.json":
+                return (0, openclawParser_1.parseOpenclawJson)(manifest);
+            case "package.json":
+                return (0, packageJsonParser_1.parsePackageJson)(manifest);
+            case "angular.json":
+            case "workspace.json":
+                return parseAngularJson(manifest);
+            case "requirements.txt":
+                return (0, pythonParsers_1.parseRequirementsTxt)(manifest);
+            case "pyproject.toml":
+                return (0, pythonParsers_1.parsePyprojectToml)(manifest);
+            case "Pipfile":
+                return (0, pythonParsers_1.parsePipfile)(manifest);
+            case "setup.cfg":
+                return (0, pythonParsers_1.parseSetupCfg)(manifest);
+            case "pom.xml":
+                return (0, javaParsers_1.parsePomXml)(manifest);
+            case "build.gradle":
+            case "build.gradle.kts":
+                return (0, javaParsers_1.parseBuildGradle)(manifest);
+            case "go.mod":
+                return (0, goParsers_1.parseGoMod)(manifest);
+            case "Cargo.toml":
+                return (0, rustParsers_1.parseCargoToml)(manifest);
+            case "global.json":
+                return (0, dotnetParsers_1.parseGlobalJson)(manifest);
+            case "Dockerfile":
+                return parseDockerfile(manifest);
+            default:
+                break;
+        }
+        // Extension-based matches
+        if (filename.endsWith(".csproj") ||
+            filename.endsWith(".fsproj") ||
+            filename.endsWith(".vbproj")) {
+            return (0, dotnetParsers_1.parseCsproj)(manifest);
+        }
+        // Files we scan but don't parse (lockfiles, CI configs, etc.)
+        return [];
+    }
+    catch (error) {
+        console.warn(`⚠️  Skipping manifest ${manifest.relativePath}: ${error.message}\n` +
+            `   This file could not be parsed. It may be malformed or use an unsupported format.\n` +
+            `   Other manifests will still be processed normally.`);
+        return [];
+    }
+}
+/**
+ * Parse all discovered manifests and return combined signals.
+ */
+function parseAllManifests(manifests) {
+    const allSignals = [];
+    for (const manifest of manifests) {
+        const signals = parseManifest(manifest);
+        allSignals.push(...signals);
+    }
+    return allSignals;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Java/JVM manifest parsers.
+ * Handles pom.xml and build.gradle(.kts) with regex-based parsing.
+ */
+import { Signal, ManifestFile } from "../types";
+/**
+ * Parse pom.xml (Maven)
+ */
+export declare function parsePomXml(manifest: ManifestFile): Signal[];
+/**
+ * Parse build.gradle or build.gradle.kts (Gradle)
+ */
+export declare function parseBuildGradle(manifest: ManifestFile): Signal[];