@thelogicatelier/sylva 1.0.11 → 1.0.13

package/dist/awareness/manifestParsers/pythonParsers.js

@@ -43,23 +43,7 @@ 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" },
-];
+const constants_1 = require("../../constants");
 function parsePythonVersion(versionSpec, sourceFile, pkgName) {
     if (!versionSpec || versionSpec.trim() === "") {
         return { certainty: "unknown", sourceFile, notes: `No version for ${pkgName}` };
@@ -110,7 +94,7 @@ function parseRequirementsTxt(manifest) {
             continue;
         const pkgName = match[1].toLowerCase();
         const versionSpec = match[2] || "";
-        const framework = PYTHON_FRAMEWORKS.find((f) => f.pkg === pkgName);
+        const framework = constants_1.PYTHON_FRAMEWORKS.find((f) => f.pkg === pkgName);
         if (framework) {
             const versionInfo = parsePythonVersion(versionSpec, manifest.relativePath, pkgName);
             signals.push({
@@ -179,7 +163,7 @@ function parsePyprojectToml(manifest) {
             if (simpleMatch) {
                 const pkgName = simpleMatch[1].toLowerCase();
                 const versionSpec = simpleMatch[2];
-                const framework = PYTHON_FRAMEWORKS.find((f) => f.pkg === pkgName);
+                const framework = constants_1.PYTHON_FRAMEWORKS.find((f) => f.pkg === pkgName);
                 if (framework) {
                     const isPinned = /^\d+\.\d+/.test(versionSpec) && !/[><=~^]/.test(versionSpec);
                     const versionInfo = isPinned
@@ -266,7 +250,7 @@ function parsePipfile(manifest) {
             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);
+                const framework = constants_1.PYTHON_FRAMEWORKS.find((f) => f.pkg === pkgName);
                 if (framework) {
                     const versionSpec = match[2];
                     const isExact = versionSpec === "*" ? false : /^\d+\.\d+/.test(versionSpec);
@@ -321,7 +305,7 @@ function parseSetupCfg(manifest) {
             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);
+                const framework = constants_1.PYTHON_FRAMEWORKS.find((f) => f.pkg === pkgName);
                 if (framework) {
                     const versionInfo = parsePythonVersion(match[2] || "", manifest.relativePath, pkgName);
                     signals.push({

package/dist/awareness/manifestParsers/rustParsers.js

@@ -40,17 +40,7 @@ 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" },
-];
+const constants_1 = require("../../constants");
 /**
  * Parse Cargo.toml
  */
@@ -117,7 +107,7 @@ function parseCargoToml(manifest) {
             }
             if (!crateName)
                 continue;
-            const framework = RUST_FRAMEWORKS.find((f) => f.crate === crateName);
+            const framework = constants_1.RUST_FRAMEWORKS.find((f) => f.crate === crateName);
             if (framework) {
                 let versionInfo;
                 if (versionStr) {

package/dist/awareness/manifestScanner.js

@@ -41,81 +41,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanManifests = scanManifests;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const constants_1 = require("../constants");
 /** Directories to skip during scanning */
-const SCAN_IGNORE_DIRS = new Set([
-    ".git",
-    "node_modules",
-    "__pycache__",
-    "venv",
-    ".venv",
-    "env",
-    ".env",
-    "dist",
-    "build",
-    "target",
-    "vendor",
-    "bin",
-    "obj",
-    "out",
-    "coverage",
-    "logs",
-    "tmp",
-    "temp",
-    ".idea",
-    ".vscode",
-    ".next",
-    ".nuxt",
-    ".svelte-kit",
-    ".angular",
-    ".DS_Store",
-]);
+const IGNORE_DIRS_SET = new Set(constants_1.SCAN_IGNORE_DIRS);
 /** Exact filenames to match as manifests */
-const MANIFEST_EXACT_NAMES = new Set([
-    "package.json",
-    "package-lock.json",
-    "yarn.lock",
-    "pnpm-lock.yaml",
-    "openclaw.json",
-    ".openclaw.json",
-    "angular.json",
-    "workspace.json",
-    "project.json",
-    "pyproject.toml",
-    "requirements.txt",
-    "poetry.lock",
-    "Pipfile",
-    "Pipfile.lock",
-    "setup.cfg",
-    "setup.py",
-    "pom.xml",
-    "build.gradle",
-    "build.gradle.kts",
-    "settings.gradle",
-    "settings.gradle.kts",
-    "gradle.properties",
-    "go.mod",
-    "go.sum",
-    "Cargo.toml",
-    "Cargo.lock",
-    "global.json",
-    "packages.lock.json",
-    "Dockerfile",
-    "docker-compose.yml",
-    "docker-compose.yaml",
-    "Makefile",
-    ".gitlab-ci.yml",
-]);
-/** File extension patterns for manifests (e.g. *.csproj) */
-const MANIFEST_EXTENSION_PATTERNS = [".csproj", ".fsproj", ".vbproj"];
-/** Maximum file size in characters to read */
-const MAX_FILE_SIZE = 500_000;
+const MANIFEST_EXACT_NAMES = new Set(constants_1.MANIFEST_EXACT_NAMES);
 /**
  * Check if a filename matches a known manifest pattern.
  */
 function isManifestFile(filename) {
     if (MANIFEST_EXACT_NAMES.has(filename))
         return true;
-    for (const ext of MANIFEST_EXTENSION_PATTERNS) {
+    for (const ext of constants_1.MANIFEST_EXTENSION_PATTERNS) {
         if (filename.endsWith(ext))
             return true;
     }
@@ -142,7 +79,7 @@ function scanManifests(repoPath) {
         }
         for (const entry of entries) {
             // Skip ignored directories and hidden dirs (except specific manifest patterns)
-            if (SCAN_IGNORE_DIRS.has(entry))
+            if (IGNORE_DIRS_SET.has(entry))
                 continue;
             const fullPath = path.join(dir, entry);
             let stat;
@@ -160,7 +97,11 @@ function scanManifests(repoPath) {
                 walk(fullPath, depth + 1);
             }
             else if (stat.isFile()) {
-                if (isManifestFile(entry) && stat.size <= MAX_FILE_SIZE) {
+                if (isManifestFile(entry)) {
+                    if (stat.size > constants_1.MAX_MANIFEST_FILE_SIZE) {
+                        // File is too large, skip it
+                        continue;
+                    }
                     results.push({
                         absolutePath: fullPath,
                         relativePath: path.relative(absoluteRoot, fullPath),

package/dist/awareness/sourceScanner.d.ts

@@ -0,0 +1,5 @@
+import { Signal } from "./types";
+/**
+ * Scan source codebase for integrations.
+ */
+export declare function scanSourceFiles(rootPath: string): Signal[];

package/dist/awareness/sourceScanner.js

@@ -0,0 +1,179 @@
+"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.scanSourceFiles = scanSourceFiles;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ignore_1 = __importDefault(require("ignore"));
+const constants_1 = require("../constants");
+const MAX_SCAN_FILES = 200;
+const MAX_LINES_PER_FILE = 500;
+/**
+ * Loads .gitignore rules from the root if available
+ */
+function loadGitIgnore(rootPath) {
+    const ig = (0, ignore_1.default)();
+    // Add hardcoded global ignores
+    for (const item of constants_1.SCAN_IGNORE_DIRS)
+        ig.add(`**/${item}/**`);
+    for (const item of constants_1.ALWAYS_IGNORE_FILES)
+        ig.add(`**/${item}`);
+    ig.add("**/*.env*"); // Cover all .env permutations globally
+    try {
+        const gitignorePath = path.join(rootPath, ".gitignore");
+        if (fs.existsSync(gitignorePath)) {
+            const content = fs.readFileSync(gitignorePath, "utf-8");
+            ig.add(content);
+        }
+    }
+    catch {
+        // Ignore errors reading .gitignore
+    }
+    return ig;
+}
+/**
+ * Collect source files sequentially via BFS
+ */
+function collectSourceFiles(dir, ig, rootPath, files = []) {
+    if (files.length >= MAX_SCAN_FILES)
+        return files;
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (files.length >= MAX_SCAN_FILES)
+                break;
+            const fullPath = path.join(dir, entry.name);
+            // Ensure posix path for gitignore matching
+            const relPath = path.relative(rootPath, fullPath).split(path.sep).join(path.posix.sep);
+            // Skip ignored files/directories
+            // Note: ignore().ignores() requires directory paths to end with '/' to match properly sometimes,
+            // but relPath works fine for most rules.
+            if (ig.ignores(relPath))
+                continue;
+            if (entry.isDirectory()) {
+                if (!ig.ignores(relPath + "/")) {
+                    collectSourceFiles(fullPath, ig, rootPath, files);
+                }
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name).toLowerCase();
+                if (constants_1.SOURCE_EXTENSIONS.includes(ext)) {
+                    files.push(fullPath);
+                }
+            }
+        }
+    }
+    catch {
+        // access errors skipped
+    }
+    return files;
+}
+/**
+ * Heuristic: check if this phrase occurs in the text
+ */
+function matchPatterns(content, patterns = []) {
+    for (const pat of patterns) {
+        if (content.includes(pat))
+            return pat;
+    }
+    return null;
+}
+/**
+ * Scan source codebase for integrations.
+ */
+function scanSourceFiles(rootPath) {
+    const ig = loadGitIgnore(rootPath);
+    const targetFiles = collectSourceFiles(rootPath, ig, rootPath);
+    const signals = [];
+    const detectedIntegrationIds = new Set();
+    for (const file of targetFiles) {
+        try {
+            // Read file and limit to N lines to keep it fast
+            const contentRaw = fs.readFileSync(file, "utf-8");
+            let content = contentRaw;
+            const lines = contentRaw.split("\n");
+            if (lines.length > MAX_LINES_PER_FILE) {
+                content = lines.slice(0, MAX_LINES_PER_FILE).join("\n");
+            }
+            // Check all integrations against this chunk
+            for (const integration of constants_1.INTEGRATIONS) {
+                if (detectedIntegrationIds.has(integration.id))
+                    continue; // Found it already somewhere
+                let reason = "";
+                let matchedPattern = "";
+                matchedPattern = matchPatterns(content, integration.urlPatterns) || "";
+                if (matchedPattern) {
+                    reason = `Found API URL pattern "${matchedPattern}"`;
+                }
+                else {
+                    matchedPattern = matchPatterns(content, integration.importPatterns) || "";
+                    if (matchedPattern) {
+                        reason = `Found SDK import pattern "${matchedPattern}"`;
+                    }
+                    else {
+                        matchedPattern = matchPatterns(content, integration.envPatterns) || "";
+                        if (matchedPattern) {
+                            reason = `Found env var reference "${matchedPattern}"`;
+                        }
+                    }
+                }
+                if (reason) {
+                    detectedIntegrationIds.add(integration.id);
+                    signals.push({
+                        kind: "integration",
+                        frameworkId: integration.id,
+                        frameworkName: integration.name,
+                        version: { certainty: "unknown", value: undefined },
+                        evidence: {
+                            file: path.relative(rootPath, file),
+                            reason: `Source code scanner detected ${integration.name}: ${reason}`,
+                        },
+                        scope: { pathRoot: rootPath },
+                    });
+                }
+            }
+            // If we found everything, stop scanning
+            if (detectedIntegrationIds.size === constants_1.INTEGRATIONS.length)
+                break;
+        }
+        catch {
+            // Ignore unreadable files
+        }
+    }
+    return signals;
+}

package/dist/awareness/types.d.ts

@@ -13,7 +13,7 @@ export interface VersionInfo {
     notes?: string;
 }
 /** Signal kinds emitted by manifest parsers */
-export type SignalKind = "framework" | "version" | "orchestrator" | "entrypoint" | "tooling";
+export type SignalKind = "framework" | "version" | "orchestrator" | "entrypoint" | "tooling" | "agent" | "subagent" | "heartbeat" | "cron" | "hook" | "skill" | "plugin" | "integration";
 /** Evidence for a detected signal */
 export interface SignalEvidence {
     file: string;

package/dist/constants.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Shared programmatic constants and integration registries for Sylva.
+ */
 export interface ModelMetadata {
     provider: string;
     tier: "primary" | "mini";
@@ -16,3 +19,44 @@ export declare const IGNORED_DIRS: Set<string>;
  * source tree so the AI reads them FIRST, preventing framework hallucination.
  */
 export declare const DEPENDENCY_MANIFESTS: Set<string>;
+export interface IntegrationDef {
+    id: string;
+    name: string;
+    urlPatterns?: string[];
+    importPatterns?: string[];
+    envPatterns?: string[];
+}
+export declare const INTEGRATIONS: IntegrationDef[];
+export declare const SOURCE_EXTENSIONS: string[];
+export declare const SCAN_IGNORE_DIRS: string[];
+export declare const ALWAYS_IGNORE_FILES: string[];
+export declare const MANIFEST_EXACT_NAMES: string[];
+export declare const MANIFEST_EXTENSION_PATTERNS: string[];
+export declare const MAX_MANIFEST_FILE_SIZE = 500000;
+/** Confidence scoring rules mapped by framework ID */
+export declare const CONFIDENCE_SCORES: Record<string, number>;
+export declare const NPM_FRAMEWORKS: {
+    depPattern: string | RegExp;
+    frameworkId: string;
+    frameworkName: string;
+}[];
+export declare const PYTHON_FRAMEWORKS: {
+    pkg: string;
+    frameworkId: string;
+    frameworkName: string;
+}[];
+export declare const JAVA_FRAMEWORKS: {
+    groupArtifact: string;
+    frameworkId: string;
+    frameworkName: string;
+}[];
+export declare const GO_FRAMEWORKS: {
+    module: string;
+    frameworkId: string;
+    frameworkName: string;
+}[];
+export declare const RUST_FRAMEWORKS: {
+    crate: string;
+    frameworkId: string;
+    frameworkName: string;
+}[];