@thelogicatelier/sylva 1.0.11 → 1.0.13

package/dist/awareness/manifestParsers/openclawParser.js

@@ -1,7 +1,21 @@
 "use strict";
 /**
- * OpenClaw manifest parser.
- * Parses openclaw.json to extract orchestrator configuration.
+ * OpenClaw manifest parser — deep extraction.
+ * Parses openclaw.json / .openclaw.json to extract:
+ *   - Orchestrator signal with version from meta
+ *   - Agent config (models, workspace, concurrency)
+ *   - Hooks (internal event scripts with paths + descriptions)
+ *   - Plugins (enabled extensions)
+ *   - Gateway config (port, auth, denied commands)
+ *   - Channels (policies, stream modes)
+ *   - Tools (web search, fetch)
+ *   - Commands / messages config
+ *
+ * Also scans the OpenClaw workspace directory for:
+ *   - Skills (reusable .md workflows)
+ *   - Subagents (background agent directories)
+ *   - Workspace .md files (AGENTS.md, IDENTITY.md, HEARTBEAT.md, etc.)
+ *   - Hook scripts
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -40,6 +54,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseOpenclawJson = parseOpenclawJson;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+// ---------------------
+// Deep JSON extraction
+// ---------------------
 function parseOpenclawJson(manifest) {
     const signals = [];
     const content = fs.readFileSync(manifest.absolutePath, "utf-8");
@@ -54,50 +71,546 @@ function parseOpenclawJson(manifest) {
         return signals;
     }
     const rootPath = path.dirname(manifest.relativePath) || ".";
-    // Primary orchestrator signal
+    // --- Extract OpenClaw version from meta ---
+    const meta = config.meta;
+    const openclawVersion = meta?.lastTouchedVersion
+        ? {
+            value: String(meta.lastTouchedVersion),
+            certainty: "exact",
+            sourceFile: manifest.relativePath,
+            notes: "From meta.lastTouchedVersion in openclaw.json",
+        }
+        : undefined;
+    // --- Primary orchestrator signal ---
     signals.push({
         kind: "orchestrator",
         frameworkId: "openclaw",
         frameworkName: "OpenClaw",
+        ...(openclawVersion ? { version: openclawVersion } : {}),
         evidence: {
             file: manifest.relativePath,
             reason: "openclaw.json configuration file found",
-            excerpt: content.length > 500 ? content.substring(0, 500) + "..." : content,
+            excerpt: openclawVersion
+                ? `OpenClaw version ${openclawVersion.value}`
+                : "OpenClaw orchestrator (version not specified in config)",
+        },
+        scope: { pathRoot: rootPath },
+    });
+    // --- Agent config ---
+    extractAgentConfig(config, manifest, rootPath, signals);
+    // --- Hooks ---
+    extractHooks(config, manifest, rootPath, signals);
+    // --- Plugins ---
+    extractPlugins(config, manifest, rootPath, signals);
+    // --- Gateway ---
+    extractGateway(config, manifest, rootPath, signals);
+    // --- Channels (expanded) ---
+    extractChannels(config, manifest, rootPath, signals);
+    // --- Tools (expanded) ---
+    extractTools(config, manifest, rootPath, signals);
+    // --- Commands + messages ---
+    extractCommandsAndMessages(config, manifest, rootPath, signals);
+    // --- Workspace scanning ---
+    scanWorkspace(config, manifest, rootPath, signals);
+    return signals;
+}
+// ---------------------
+// Section extractors
+// ---------------------
+function extractAgentConfig(config, manifest, rootPath, signals) {
+    const agents = config.agents;
+    if (!agents || typeof agents !== "object")
+        return;
+    const defaults = agents.defaults;
+    if (!defaults || typeof defaults !== "object")
+        return;
+    // Primary model
+    const model = defaults.model;
+    const primaryModel = model?.primary ? String(model.primary) : undefined;
+    // Available models
+    const models = defaults.models;
+    const modelCatalog = models ? Object.keys(models) : [];
+    // Workspace path
+    const workspace = defaults.workspace ? String(defaults.workspace) : undefined;
+    // Concurrency
+    const maxConcurrent = typeof defaults.maxConcurrent === "number" ? defaults.maxConcurrent : undefined;
+    const subagentConfig = defaults.subagents;
+    const subagentMaxConcurrent = subagentConfig && typeof subagentConfig.maxConcurrent === "number"
+        ? subagentConfig.maxConcurrent
+        : undefined;
+    // Compaction
+    const compaction = defaults.compaction;
+    const compactionMode = compaction?.mode ? String(compaction.mode) : undefined;
+    const details = [];
+    if (primaryModel)
+        details.push(`primary model: ${primaryModel}`);
+    if (modelCatalog.length > 0)
+        details.push(`${modelCatalog.length} model(s) available`);
+    if (workspace)
+        details.push(`workspace: ${workspace}`);
+    if (maxConcurrent)
+        details.push(`maxConcurrent: ${maxConcurrent}`);
+    if (subagentMaxConcurrent)
+        details.push(`subagent maxConcurrent: ${subagentMaxConcurrent}`);
+    if (compactionMode)
+        details.push(`compaction: ${compactionMode}`);
+    signals.push({
+        kind: "agent",
+        frameworkId: "openclaw-agent-config",
+        frameworkName: "OpenClaw Agent Config",
+        evidence: {
+            file: manifest.relativePath,
+            reason: "Agent configuration in openclaw.json",
+            excerpt: details.join("; "),
         },
         scope: { pathRoot: rootPath },
     });
-    // Extract tool signals
+    // Emit individual model entries for the LLM to know available models
+    if (modelCatalog.length > 0) {
+        signals.push({
+            kind: "agent",
+            frameworkId: "openclaw-model-catalog",
+            frameworkName: "OpenClaw Model Catalog",
+            evidence: {
+                file: manifest.relativePath,
+                reason: "Available LLM models configured in openclaw.json",
+                excerpt: modelCatalog.join(", "),
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+}
+function extractHooks(config, manifest, rootPath, signals) {
+    const hooks = config.hooks;
+    if (!hooks || typeof hooks !== "object")
+        return;
+    const internal = hooks.internal;
+    if (!internal || typeof internal !== "object")
+        return;
+    if (internal.enabled === false)
+        return;
+    const entries = internal.entries;
+    if (!entries || typeof entries !== "object")
+        return;
+    for (const [hookName, hookConfig] of Object.entries(entries)) {
+        if (!hookConfig || typeof hookConfig !== "object")
+            continue;
+        const enabled = hookConfig.enabled !== false; // default true
+        const hookPath = hookConfig.path ? String(hookConfig.path) : undefined;
+        const description = hookConfig.description ? String(hookConfig.description) : undefined;
+        const details = [`enabled: ${enabled}`];
+        if (hookPath)
+            details.push(`path: ${hookPath}`);
+        if (description)
+            details.push(`desc: ${description}`);
+        signals.push({
+            kind: "hook",
+            frameworkId: `openclaw-hook-${hookName}`,
+            frameworkName: `OpenClaw Hook: ${hookName}`,
+            evidence: {
+                file: manifest.relativePath,
+                reason: description || `Hook '${hookName}' configured in openclaw.json`,
+                excerpt: details.join("; "),
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+}
+function extractPlugins(config, manifest, rootPath, signals) {
+    const plugins = config.plugins;
+    if (!plugins || typeof plugins !== "object")
+        return;
+    const entries = plugins.entries;
+    if (!entries || typeof entries !== "object")
+        return;
+    for (const [pluginName, pluginConfig] of Object.entries(entries)) {
+        if (!pluginConfig || typeof pluginConfig !== "object")
+            continue;
+        const enabled = pluginConfig.enabled !== false;
+        signals.push({
+            kind: "plugin",
+            frameworkId: `openclaw-plugin-${pluginName}`,
+            frameworkName: `OpenClaw Plugin: ${pluginName}`,
+            evidence: {
+                file: manifest.relativePath,
+                reason: `Plugin '${pluginName}' ${enabled ? "enabled" : "disabled"} in openclaw.json`,
+                excerpt: `enabled: ${enabled}`,
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+}
+function extractGateway(config, manifest, rootPath, signals) {
+    const gateway = config.gateway;
+    if (!gateway || typeof gateway !== "object")
+        return;
+    const details = [];
+    if (gateway.port)
+        details.push(`port: ${gateway.port}`);
+    if (gateway.mode)
+        details.push(`mode: ${gateway.mode}`);
+    if (gateway.bind)
+        details.push(`bind: ${gateway.bind}`);
+    const auth = gateway.auth;
+    if (auth?.mode)
+        details.push(`auth: ${auth.mode}`);
+    const tailscale = gateway.tailscale;
+    if (tailscale?.mode)
+        details.push(`tailscale: ${tailscale.mode}`);
+    const nodes = gateway.nodes;
+    const denyCommands = nodes?.denyCommands;
+    if (denyCommands && Array.isArray(denyCommands)) {
+        details.push(`denied commands: ${denyCommands.join(", ")}`);
+    }
+    signals.push({
+        kind: "tooling",
+        frameworkId: "openclaw-gateway",
+        frameworkName: "OpenClaw Gateway",
+        evidence: {
+            file: manifest.relativePath,
+            reason: "Gateway configuration in openclaw.json",
+            excerpt: details.join("; "),
+        },
+        scope: { pathRoot: rootPath },
+    });
+}
+function extractChannels(config, manifest, rootPath, signals) {
+    const channels = config.channels;
+    if (!channels || typeof channels !== "object")
+        return;
+    for (const [channelName, channelConfig] of Object.entries(channels)) {
+        if (!channelConfig || typeof channelConfig !== "object")
+            continue;
+        const ch = channelConfig;
+        const details = [];
+        if (ch.enabled === false)
+            details.push("disabled");
+        if (ch.dmPolicy)
+            details.push(`dmPolicy: ${ch.dmPolicy}`);
+        if (ch.groupPolicy)
+            details.push(`groupPolicy: ${ch.groupPolicy}`);
+        if (ch.streamMode)
+            details.push(`streamMode: ${ch.streamMode}`);
+        if (ch.selfChatMode !== undefined)
+            details.push(`selfChat: ${ch.selfChatMode}`);
+        if (ch.debounceMs !== undefined)
+            details.push(`debounce: ${ch.debounceMs}ms`);
+        if (ch.mediaMaxMb)
+            details.push(`mediaMax: ${ch.mediaMaxMb}MB`);
+        signals.push({
+            kind: "tooling",
+            frameworkId: `openclaw-channel-${channelName}`,
+            frameworkName: `OpenClaw Channel: ${channelName}`,
+            evidence: {
+                file: manifest.relativePath,
+                reason: `Channel '${channelName}' configured in openclaw.json`,
+                excerpt: details.length > 0 ? details.join("; ") : `channel ${channelName} configured`,
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+}
+function extractTools(config, manifest, rootPath, signals) {
     const tools = config.tools;
-    if (tools && typeof tools === "object") {
-        for (const [toolName, toolConfig] of Object.entries(tools)) {
+    if (!tools || typeof tools !== "object")
+        return;
+    for (const [toolName, toolConfig] of Object.entries(tools)) {
+        if (!toolConfig || typeof toolConfig !== "object")
+            continue;
+        // Build a summary of the tool's sub-capabilities
+        const subCapabilities = [];
+        for (const [subName, subConfig] of Object.entries(toolConfig)) {
+            if (subConfig && typeof subConfig === "object") {
+                const sc = subConfig;
+                const enabled = sc.enabled !== false;
+                subCapabilities.push(`${subName}: ${enabled ? "enabled" : "disabled"}`);
+            }
+        }
+        signals.push({
+            kind: "tooling",
+            frameworkId: `openclaw-tool-${toolName}`,
+            frameworkName: `OpenClaw Tool: ${toolName}`,
+            evidence: {
+                file: manifest.relativePath,
+                reason: `Tool '${toolName}' configured in openclaw.json`,
+                excerpt: subCapabilities.length > 0 ? subCapabilities.join("; ") : `tool ${toolName} configured`,
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+}
+function extractCommandsAndMessages(config, manifest, rootPath, signals) {
+    const commands = config.commands;
+    if (commands && typeof commands === "object") {
+        const details = [];
+        if (commands.native)
+            details.push(`native: ${commands.native}`);
+        if (commands.nativeSkills)
+            details.push(`nativeSkills: ${commands.nativeSkills}`);
+        if (details.length > 0) {
             signals.push({
                 kind: "tooling",
-                frameworkId: `openclaw-tool-${toolName}`,
-                frameworkName: `OpenClaw Tool: ${toolName}`,
+                frameworkId: "openclaw-commands",
+                frameworkName: "OpenClaw Commands",
                 evidence: {
                     file: manifest.relativePath,
-                    reason: `Tool '${toolName}' configured in openclaw.json`,
-                    excerpt: JSON.stringify(toolConfig, null, 2).substring(0, 200),
+                    reason: "Command configuration in openclaw.json",
+                    excerpt: details.join("; "),
                 },
                 scope: { pathRoot: rootPath },
             });
         }
     }
-    // Extract channel signals
-    const channels = config.channels;
-    if (channels && typeof channels === "object") {
-        for (const [channelName] of Object.entries(channels)) {
+    const messages = config.messages;
+    if (messages && typeof messages === "object") {
+        const details = [];
+        if (messages.ackReactionScope)
+            details.push(`ackReactionScope: ${messages.ackReactionScope}`);
+        if (details.length > 0) {
             signals.push({
                 kind: "tooling",
-                frameworkId: `openclaw-channel-${channelName}`,
-                frameworkName: `OpenClaw Channel: ${channelName}`,
+                frameworkId: "openclaw-messages",
+                frameworkName: "OpenClaw Messages",
                 evidence: {
                     file: manifest.relativePath,
-                    reason: `Channel '${channelName}' configured in openclaw.json`,
+                    reason: "Message configuration in openclaw.json",
+                    excerpt: details.join("; "),
                 },
                 scope: { pathRoot: rootPath },
             });
         }
     }
-    return signals;
+}
+// ---------------------
+// Workspace scanner
+// ---------------------
+function scanWorkspace(config, manifest, rootPath, signals) {
+    // Resolve workspace directory:
+    // 1. From agents.defaults.workspace in config
+    // 2. Fallback to sibling "workspace/" directory relative to the config file
+    const agents = config.agents;
+    const defaults = agents?.defaults;
+    const configuredWorkspace = defaults?.workspace ? String(defaults.workspace) : undefined;
+    const configDir = path.dirname(manifest.absolutePath);
+    let workspaceDir;
+    if (configuredWorkspace) {
+        // Could be absolute or relative — try both
+        const candidate = path.isAbsolute(configuredWorkspace)
+            ? configuredWorkspace
+            : path.resolve(configDir, configuredWorkspace);
+        if (existsAndIsDir(candidate)) {
+            workspaceDir = candidate;
+        }
+    }
+    if (!workspaceDir) {
+        // Fallback: sibling "workspace/" directory
+        const fallback = path.join(configDir, "workspace");
+        if (existsAndIsDir(fallback)) {
+            workspaceDir = fallback;
+        }
+    }
+    if (!workspaceDir)
+        return;
+    const workspaceRel = path.relative(path.dirname(manifest.absolutePath), workspaceDir);
+    // Scan workspace .md files (identity layer)
+    scanWorkspaceMdFiles(workspaceDir, workspaceRel, manifest, rootPath, signals);
+    // Scan skills
+    scanSkills(workspaceDir, workspaceRel, manifest, rootPath, signals);
+    // Scan subagents
+    scanSubagents(workspaceDir, workspaceRel, manifest, rootPath, signals);
+}
+function scanWorkspaceMdFiles(workspaceDir, workspaceRel, manifest, rootPath, signals) {
+    const WORKSPACE_FILES = {
+        "AGENTS.md": "Agent behavioral instructions and skill routing",
+        "IDENTITY.md": "Agent identity, personality, and avatar",
+        "HEARTBEAT.md": "Periodic awareness checklist (cron-like proactive checks)",
+        "MEMORY.md": "Long-term curated memory store",
+        "SOUL.md": "Agent personality and core values",
+        "USER.md": "User profile and preferences",
+        "TOOLS.md": "Tool configuration and capabilities",
+        "OPTIMIZATION.md": "Performance and cost optimization rules",
+    };
+    for (const [filename, description] of Object.entries(WORKSPACE_FILES)) {
+        const filePath = path.join(workspaceDir, filename);
+        if (!existsAndIsFile(filePath))
+            continue;
+        // For HEARTBEAT.md, check if it has actual tasks (non-empty, non-comment content)
+        if (filename === "HEARTBEAT.md") {
+            const heartbeatContent = safeReadFile(filePath);
+            const hasActiveTasks = heartbeatContent
+                ? heartbeatContent.split("\n").some((line) => line.trim() && !line.trim().startsWith("#"))
+                : false;
+            signals.push({
+                kind: "heartbeat",
+                frameworkId: "openclaw-heartbeat",
+                frameworkName: "OpenClaw Heartbeat",
+                evidence: {
+                    file: path.join(workspaceRel, filename),
+                    reason: hasActiveTasks
+                        ? "HEARTBEAT.md found with active periodic tasks"
+                        : "HEARTBEAT.md found but no active tasks configured",
+                    excerpt: hasActiveTasks ? "Status: ACTIVE" : "Status: INACTIVE (empty/comments only)",
+                },
+                scope: { pathRoot: rootPath },
+            });
+            continue;
+        }
+        // For IDENTITY.md, extract the agent name if present
+        let excerpt = description;
+        if (filename === "IDENTITY.md") {
+            const identityContent = safeReadFile(filePath);
+            if (identityContent) {
+                const nameMatch = identityContent.match(/\*\*Name:\*\*\s*(.+)/);
+                if (nameMatch) {
+                    excerpt = `Agent name: ${nameMatch[1].trim()} — ${description}`;
+                }
+            }
+        }
+        signals.push({
+            kind: "agent",
+            frameworkId: `openclaw-workspace-${filename.replace(".md", "").toLowerCase()}`,
+            frameworkName: `OpenClaw Workspace: ${filename}`,
+            evidence: {
+                file: path.join(workspaceRel, filename),
+                reason: `Workspace file ${filename} found`,
+                excerpt,
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+}
+function scanSkills(workspaceDir, workspaceRel, manifest, rootPath, signals) {
+    const skillsDir = path.join(workspaceDir, "skills");
+    if (!existsAndIsDir(skillsDir))
+        return;
+    let entries;
+    try {
+        entries = fs.readdirSync(skillsDir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (!entry.endsWith(".md"))
+            continue;
+        if (entry === "SKILL_INDEX.md")
+            continue; // Index file, not a skill itself
+        const skillPath = path.join(skillsDir, entry);
+        if (!existsAndIsFile(skillPath))
+            continue;
+        // Read first meaningful line for description
+        const content = safeReadFile(skillPath);
+        let description = `Skill workflow: ${entry.replace(".md", "")}`;
+        if (content) {
+            const lines = content.split("\n").filter((l) => l.trim());
+            const firstLine = lines[0] || "";
+            if (firstLine.startsWith("#")) {
+                description = firstLine.replace(/^#+\s*/, "").trim();
+            }
+        }
+        const skillName = entry
+            .replace(".md", "")
+            .replace(/-/g, " ")
+            .replace(/\b\w/g, (c) => c.toUpperCase());
+        signals.push({
+            kind: "skill",
+            frameworkId: `openclaw-skill-${entry.replace(".md", "")}`,
+            frameworkName: `OpenClaw Skill: ${skillName}`,
+            evidence: {
+                file: path.join(workspaceRel, "skills", entry),
+                reason: description,
+                excerpt: `Skill file: ${entry}`,
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+}
+function scanSubagents(workspaceDir, workspaceRel, manifest, rootPath, signals) {
+    const subagentsDir = path.join(workspaceDir, "subagents");
+    if (!existsAndIsDir(subagentsDir))
+        return;
+    let entries;
+    try {
+        entries = fs.readdirSync(subagentsDir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const entryPath = path.join(subagentsDir, entry);
+        if (!existsAndIsDir(entryPath))
+            continue;
+        // List files in the subagent directory
+        let subFiles;
+        try {
+            subFiles = fs.readdirSync(entryPath).filter((f) => {
+                const fp = path.join(entryPath, f);
+                try {
+                    return fs.statSync(fp).isFile() && !f.startsWith(".");
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
+        catch {
+            continue;
+        }
+        // Filter out __pycache__ etc
+        const meaningfulFiles = subFiles.filter((f) => !f.endsWith(".pyc") && f !== "__pycache__");
+        // Try to read protocol.md for description
+        let description = `Subagent: ${entry}`;
+        const protocolPath = path.join(entryPath, "protocol.md");
+        if (existsAndIsFile(protocolPath)) {
+            const content = safeReadFile(protocolPath);
+            if (content) {
+                const lines = content.split("\n").filter((l) => l.trim());
+                const firstLine = lines[0] || "";
+                if (firstLine.startsWith("#")) {
+                    description = firstLine.replace(/^#+\s*/, "").trim();
+                }
+            }
+        }
+        const subagentName = entry.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+        signals.push({
+            kind: "subagent",
+            frameworkId: `openclaw-subagent-${entry}`,
+            frameworkName: `OpenClaw Subagent: ${subagentName}`,
+            evidence: {
+                file: path.join(workspaceRel, "subagents", entry),
+                reason: description,
+                excerpt: meaningfulFiles.length > 0
+                    ? `Files: ${meaningfulFiles.join(", ")}`
+                    : "Empty subagent directory",
+            },
+            scope: { pathRoot: rootPath },
+        });
+    }
+}
+// ---------------------
+// Helpers
+// ---------------------
+function existsAndIsDir(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function existsAndIsFile(p) {
+    try {
+        return fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function safeReadFile(p) {
+    try {
+        return fs.readFileSync(p, "utf-8");
+    }
+    catch {
+        return null;
+    }
 }

package/dist/awareness/manifestParsers/packageJsonParser.js

@@ -41,29 +41,7 @@ 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" },
-];
+const constants_1 = require("../../constants");
 /**
  * Determine version certainty from a semver-like string.
  */
@@ -126,7 +104,7 @@ function parsePackageJson(manifest) {
         scope: { pathRoot: rootPath },
     });
     // Detect frameworks from dependencies
-    for (const rule of FRAMEWORK_DETECTION_RULES) {
+    for (const rule of constants_1.NPM_FRAMEWORKS) {
         const depName = typeof rule.depPattern === "string" ? rule.depPattern : undefined;
         let matchedDep;
         let matchedVersion;