@agentrhq/webcmd 0.1.1 → 0.2.0

package/dist/src/pipeline/template.test.js

@@ -0,0 +1,197 @@
+/**
+ * Tests for the pipeline template engine: render, evalExpr, resolvePath.
+ */
+import { describe, it, expect } from 'vitest';
+import { render, evalExpr, resolvePath, normalizeEvaluateSource } from './template.js';
+describe('resolvePath', () => {
+    it('resolves args path', () => {
+        expect(resolvePath('args.limit', { args: { limit: 20 } })).toBe(20);
+    });
+    it('resolves nested args path', () => {
+        expect(resolvePath('args.query.keyword', { args: { query: { keyword: 'test' } } })).toBe('test');
+    });
+    it('resolves item path', () => {
+        expect(resolvePath('item.title', { item: { title: 'Hello' } })).toBe('Hello');
+    });
+    it('resolves implicit item path (no prefix)', () => {
+        expect(resolvePath('title', { item: { title: 'World' } })).toBe('World');
+    });
+    it('resolves index', () => {
+        expect(resolvePath('index', { index: 5 })).toBe(5);
+    });
+    it('resolves data path', () => {
+        expect(resolvePath('data.items', { data: { items: [1, 2, 3] } })).toEqual([1, 2, 3]);
+    });
+    it('resolves root path', () => {
+        expect(resolvePath('root.items', { root: { items: [1, 2, 3] } })).toEqual([1, 2, 3]);
+    });
+    it('returns null for missing path', () => {
+        expect(resolvePath('args.missing', { args: {} })).toBeUndefined();
+    });
+    it('resolves array index', () => {
+        expect(resolvePath('data.0', { data: ['a', 'b'] })).toBe('a');
+    });
+});
+describe('evalExpr', () => {
+    it('evaluates default filter', () => {
+        expect(evalExpr('args.limit | default(20)', { args: {} })).toBe(20);
+    });
+    it('uses actual value over default', () => {
+        expect(evalExpr('args.limit | default(20)', { args: { limit: 10 } })).toBe(10);
+    });
+    it('evaluates string default', () => {
+        expect(evalExpr("args.name | default('unknown')", { args: {} })).toBe('unknown');
+    });
+    it('evaluates arithmetic: index + 1', () => {
+        expect(evalExpr('index + 1', { index: 0 })).toBe(1);
+    });
+    it('evaluates arithmetic: index * 2', () => {
+        expect(evalExpr('index * 2', { index: 5 })).toBe(10);
+    });
+    it('evaluates || fallback', () => {
+        expect(evalExpr("item.name || 'N/A'", { item: {} })).toBe('N/A');
+    });
+    it('evaluates || with truthy left', () => {
+        expect(evalExpr("item.name || 'N/A'", { item: { name: 'Alice' } })).toBe('Alice');
+    });
+    it('evaluates chained || fallback (issue #303)', () => {
+        // When first two are falsy, should evaluate through to the string literal
+        expect(evalExpr("item.a || item.b || 'default'", { item: {} })).toBe('default');
+    });
+    it('evaluates chained || with middle value truthy', () => {
+        expect(evalExpr("item.a || item.b || 'default'", { item: { b: 'middle' } })).toBe('middle');
+    });
+    it('evaluates chained || with first value truthy', () => {
+        expect(evalExpr("item.a || item.b || 'default'", { item: { a: 'first', b: 'middle' } })).toBe('first');
+    });
+    it('evaluates || with 0 as falsy left (JS semantics)', () => {
+        expect(evalExpr("item.count || 'N/A'", { item: { count: 0 } })).toBe('N/A');
+    });
+    it('evaluates || with empty string as falsy left', () => {
+        expect(evalExpr("item.name || 'unknown'", { item: { name: '' } })).toBe('unknown');
+    });
+    it('evaluates || with numeric fallback returning number type', () => {
+        expect(evalExpr('item.a || 42', { item: {} })).toBe(42);
+    });
+    it('evaluates 4-way chained ||', () => {
+        expect(evalExpr("item.a || item.b || item.c || 'last'", { item: { c: 'third' } })).toBe('third');
+    });
+    it('handles || combined with pipe filter', () => {
+        expect(evalExpr("item.a || item.b | upper", { item: { b: 'hello' } })).toBe('HELLO');
+    });
+    it('resolves simple path', () => {
+        expect(evalExpr('item.title', { item: { title: 'Test' } })).toBe('Test');
+    });
+    it('evaluates JS helper expressions', () => {
+        expect(evalExpr('encodeURIComponent(args.keyword)', { args: { keyword: 'hello world' } })).toBe('hello%20world');
+    });
+    it('evaluates ternary expressions', () => {
+        expect(evalExpr("args.kind === 'tech' ? 'technology' : args.kind", { args: { kind: 'tech' } })).toBe('technology');
+    });
+    it('evaluates method calls on values', () => {
+        expect(evalExpr("args.username.startsWith('@') ? args.username : '@' + args.username", { args: { username: 'alice' } })).toBe('@alice');
+    });
+    it('rejects constructor-based sandbox escapes', () => {
+        expect(evalExpr("args['cons' + 'tructor']['constructor']('return process')()", { args: {} })).toBeUndefined();
+    });
+    it('applies join filter', () => {
+        expect(evalExpr('item.tags | join(,)', { item: { tags: ['a', 'b', 'c'] } })).toBe('a,b,c');
+    });
+    it('applies upper filter', () => {
+        expect(evalExpr('item.name | upper', { item: { name: 'hello' } })).toBe('HELLO');
+    });
+    it('applies lower filter', () => {
+        expect(evalExpr('item.name | lower', { item: { name: 'HELLO' } })).toBe('hello');
+    });
+    it('applies truncate filter', () => {
+        expect(evalExpr('item.text | truncate(5)', { item: { text: 'Hello World!' } })).toBe('Hello...');
+    });
+    it('chains filters', () => {
+        expect(evalExpr('item.name | upper | truncate(3)', { item: { name: 'hello' } })).toBe('HEL...');
+    });
+    it('applies length filter', () => {
+        expect(evalExpr('item.items | length', { item: { items: [1, 2, 3] } })).toBe(3);
+    });
+    it('applies json filter to strings with quotes', () => {
+        expect(evalExpr('args.keyword | json', { args: { keyword: "O'Reilly" } })).toBe('"O\'Reilly"');
+    });
+    it('applies json filter to nullish values', () => {
+        expect(evalExpr('args.keyword | json', { args: {} })).toBe('null');
+    });
+});
+describe('render', () => {
+    it('renders full expression', () => {
+        expect(render('${{ args.limit }}', { args: { limit: 30 } })).toBe(30);
+    });
+    it('renders inline expression in string', () => {
+        expect(render('Hello ${{ item.name }}!', { item: { name: 'World' } })).toBe('Hello World!');
+    });
+    it('renders multiple inline expressions', () => {
+        expect(render('${{ item.first }}-${{ item.second }}', { item: { first: 'X', second: 'Y' } })).toBe('X-Y');
+    });
+    it('returns non-string values as-is', () => {
+        expect(render(42, {})).toBe(42);
+        expect(render(null, {})).toBeNull();
+        expect(render(undefined, {})).toBeUndefined();
+    });
+    it('returns full expression result as native type', () => {
+        expect(render('${{ args.list }}', { args: { list: [1, 2, 3] } })).toEqual([1, 2, 3]);
+    });
+    it('renders URL template', () => {
+        expect(render('https://api.example.com/search?q=${{ args.keyword }}', { args: { keyword: 'test' } })).toBe('https://api.example.com/search?q=test');
+    });
+    it('renders inline helper expressions', () => {
+        expect(render('https://example.com/search?q=${{ encodeURIComponent(args.keyword) }}', { args: { keyword: 'hello world' } })).toBe('https://example.com/search?q=hello%20world');
+    });
+    it('renders full multiline expressions', () => {
+        expect(render("${{\n  args.topic ? `https://medium.com/tag/${args.topic}` : 'https://medium.com/tag/technology'\n}}", { args: { topic: 'ai' } })).toBe('https://medium.com/tag/ai');
+    });
+    it('renders block expressions with surrounding whitespace', () => {
+        expect(render("\n  ${{ args.kind === 'tech' ? 'technology' : args.kind }}\n", { args: { kind: 'tech' } })).toBe('technology');
+    });
+});
+describe('normalizeEvaluateSource', () => {
+    it('wraps bare expression', () => {
+        expect(normalizeEvaluateSource('document.title')).toBe('() => (document.title)');
+    });
+    it('passes through arrow function', () => {
+        expect(normalizeEvaluateSource('() => 42')).toBe('() => 42');
+    });
+    it('passes through async arrow function', () => {
+        const src = 'async () => { return 1; }';
+        expect(normalizeEvaluateSource(src)).toBe(src);
+    });
+    it('passes through named function', () => {
+        const src = 'function foo() { return 1; }';
+        expect(normalizeEvaluateSource(src)).toBe(src);
+    });
+    it('wraps IIFE pattern', () => {
+        const src = '(async () => { return 1; })()';
+        expect(normalizeEvaluateSource(src)).toBe(`() => (${src})`);
+    });
+    it('handles empty string', () => {
+        expect(normalizeEvaluateSource('')).toBe('() => undefined');
+    });
+});
+describe('sanitizeContext (via VM sandbox path)', () => {
+    it('coerces BigInt fields to string instead of silently dropping the branch', () => {
+        // Previously a BigInt anywhere in args would make JSON.stringify throw and
+        // sanitizeContext returned {}, so any reference to args.id in the JS
+        // sandbox would resolve to undefined. We now serialize BigInt as string
+        // so the value survives the sandbox copy.
+        const id = BigInt('9007199254740993'); // > Number.MAX_SAFE_INTEGER
+        const ctx = { args: { id } };
+        // Use an expression that forces evalJsExpr (not the resolvePath fast path)
+        // so it goes through sanitizeContext + VM sandbox.
+        expect(evalExpr('String(args.id)', ctx)).toBe('9007199254740993');
+    });
+    it('does not crash on circular references (returns {} after warning)', () => {
+        // Circular refs still can't be safely round-tripped; verify the
+        // fallback is the empty-object path, not a crash.
+        const args = { keep: 'me' };
+        args.self = args;
+        const ctx = { args };
+        // The expression must not throw even if the args object has a cycle.
+        expect(() => evalExpr('args.keep || "fallback"', ctx)).not.toThrow();
+    });
+});

package/dist/src/pipeline/transform.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for pipeline transform steps: select, map, filter, sort, limit.
+ */
+export {};

package/dist/src/pipeline/transform.test.js

@@ -0,0 +1,133 @@
+/**
+ * Tests for pipeline transform steps: select, map, filter, sort, limit.
+ */
+import { describe, it, expect } from 'vitest';
+import { stepSelect, stepMap, stepFilter, stepSort, stepLimit } from './steps/transform.js';
+const SAMPLE_DATA = [
+    { title: 'Alpha', score: 10, author: 'Alice' },
+    { title: 'Beta', score: 30, author: 'Bob' },
+    { title: 'Gamma', score: 20, author: 'Charlie' },
+];
+describe('stepSelect', () => {
+    it('selects nested path', async () => {
+        const data = { result: { items: [1, 2, 3] } };
+        const result = await stepSelect(null, 'result.items', data, {});
+        expect(result).toEqual([1, 2, 3]);
+    });
+    it('selects array by index', async () => {
+        const data = { list: ['a', 'b', 'c'] };
+        const result = await stepSelect(null, 'list.1', data, {});
+        expect(result).toBe('b');
+    });
+    it('returns null for missing path', async () => {
+        const result = await stepSelect(null, 'missing.path', { foo: 1 }, {});
+        expect(result).toBeNull();
+    });
+    it('returns data as-is for non-object', async () => {
+        const result = await stepSelect(null, 'foo', 'string-data', {});
+        expect(result).toBe('string-data');
+    });
+});
+describe('stepMap', () => {
+    it('maps array items', async () => {
+        const result = await stepMap(null, {
+            name: '${{ item.title }}',
+            rank: '${{ index + 1 }}',
+        }, SAMPLE_DATA, {});
+        expect(result).toEqual([
+            { name: 'Alpha', rank: 1 },
+            { name: 'Beta', rank: 2 },
+            { name: 'Gamma', rank: 3 },
+        ]);
+    });
+    it('handles single object', async () => {
+        const result = await stepMap(null, {
+            name: '${{ item.title }}',
+        }, { title: 'Solo' }, {});
+        expect(result).toEqual([{ name: 'Solo' }]);
+    });
+    it('returns null/undefined as-is', async () => {
+        expect(await stepMap(null, { x: '${{ item.x }}' }, null, {})).toBeNull();
+    });
+    it('supports inline select before mapping', async () => {
+        const result = await stepMap(null, {
+            select: 'posts',
+            title: '${{ item.title }}',
+            rank: '${{ index + 1 }}',
+        }, { posts: [{ title: 'One' }, { title: 'Two' }] }, {});
+        expect(result).toEqual([
+            { title: 'One', rank: 1 },
+            { title: 'Two', rank: 2 },
+        ]);
+    });
+    it('keeps data bound to the selected source and exposes root separately', async () => {
+        const result = await stepMap(null, {
+            select: 'bids',
+            bid_price: '${{ data[index][0] }}',
+            ask_price: '${{ root.asks[index][0] }}',
+        }, {
+            bids: [['100', '2'], ['99', '3']],
+            asks: [['101', '1'], ['102', '4']],
+        }, {});
+        expect(result).toEqual([
+            { bid_price: '100', ask_price: '101' },
+            { bid_price: '99', ask_price: '102' },
+        ]);
+    });
+});
+describe('stepFilter', () => {
+    it('filters by expression', async () => {
+        const result = await stepFilter(null, 'item.score', SAMPLE_DATA, {});
+        expect(result).toHaveLength(3); // all truthy
+    });
+    it('returns non-array as-is', async () => {
+        const result = await stepFilter(null, 'item.x', 'not-array', {});
+        expect(result).toBe('not-array');
+    });
+});
+describe('stepSort', () => {
+    it('sorts ascending by key', async () => {
+        const result = await stepSort(null, 'score', SAMPLE_DATA, {});
+        expect(result.map((r) => r.title)).toEqual(['Alpha', 'Gamma', 'Beta']);
+    });
+    it('sorts descending', async () => {
+        const result = await stepSort(null, { by: 'score', order: 'desc' }, SAMPLE_DATA, {});
+        expect(result.map((r) => r.title)).toEqual(['Beta', 'Gamma', 'Alpha']);
+    });
+    it('does not mutate original', async () => {
+        const original = [...SAMPLE_DATA];
+        await stepSort(null, 'score', SAMPLE_DATA, {});
+        expect(SAMPLE_DATA).toEqual(original);
+    });
+    it('sorts string-encoded numbers naturally by default', async () => {
+        const data = [
+            { name: 'A', volume: '99' },
+            { name: 'B', volume: '1000' },
+            { name: 'C', volume: '250' },
+        ];
+        const result = await stepSort(null, { by: 'volume', order: 'desc' }, data, {});
+        expect(result.map((r) => r.name)).toEqual(['B', 'C', 'A']);
+    });
+    it('handles missing fields gracefully', async () => {
+        const data = [
+            { name: 'A', value: '10' },
+            { name: 'B' },
+            { name: 'C', value: '5' },
+        ];
+        const result = await stepSort(null, { by: 'value', order: 'asc' }, data, {});
+        expect(result.map((r) => r.name)).toEqual(['B', 'C', 'A']);
+    });
+});
+describe('stepLimit', () => {
+    it('limits array to N items', async () => {
+        const result = await stepLimit(null, '2', SAMPLE_DATA, {});
+        expect(result).toHaveLength(2);
+    });
+    it('limits using template expression', async () => {
+        const result = await stepLimit(null, '${{ args.limit }}', SAMPLE_DATA, { limit: 1 });
+        expect(result).toHaveLength(1);
+    });
+    it('returns non-array as-is', async () => {
+        expect(await stepLimit(null, '5', 'string', {})).toBe('string');
+    });
+});

package/dist/src/plugin-manifest.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Plugin manifest: reads and validates webcmd-plugin.json files.
+ *
+ * Supports two modes:
+ * 1. Single plugin: repo root IS the plugin directory.
+ * 2. Monorepo: repo contains multiple plugins declared in `plugins` field.
+ */
+export interface SubPluginEntry {
+    /** Relative path from repo root to the sub-plugin directory. */
+    path: string;
+    version?: string;
+    description?: string;
+    /** Semver range for webcmd compatibility (overrides top-level). */
+    webcmd?: string;
+    /** When true, this sub-plugin is skipped during install. */
+    disabled?: boolean;
+}
+export interface PluginManifest {
+    /** Plugin name (single-plugin mode). */
+    name?: string;
+    /** Semantic version of the plugin (single-plugin mode). */
+    version?: string;
+    /** Semver range for webcmd compatibility, e.g. ">=1.0.0". */
+    webcmd?: string;
+    /** Human-readable description. */
+    description?: string;
+    /** Monorepo sub-plugins. Key = logical plugin name. */
+    plugins?: Record<string, SubPluginEntry>;
+}
+export declare const MANIFEST_FILENAME = "webcmd-plugin.json";
+/**
+ * Read and parse webcmd-plugin.json from a directory.
+ * Returns null if the file does not exist or is unparseable.
+ */
+export declare function readPluginManifest(dir: string): PluginManifest | null;
+/** Returns true when the manifest declares a monorepo (has `plugins` field). */
+export declare function isMonorepo(manifest: PluginManifest): boolean;
+/**
+ * Get the list of enabled sub-plugins from a monorepo manifest.
+ * Returns entries sorted by key name.
+ */
+export declare function getEnabledPlugins(manifest: PluginManifest): Array<{
+    name: string;
+    entry: SubPluginEntry;
+}>;
+/**
+ * Check if the current webcmd version satisfies a semver range string.
+ *
+ * Supports a simplified subset of semver ranges:
+ *   ">=1.0.0"   – greater than or equal
+ *   "<=1.5.0"   – less than or equal
+ *   ">1.0.0"    – strictly greater
+ *   "<2.0.0"    – strictly less
+ *   "^1.2.0"    – compatible (>=1.2.0 and <2.0.0)
+ *   "~1.2.0"    – patch-level (>=1.2.0 and <1.3.0)
+ *   "1.2.0"     – exact match
+ *   ">=1.0.0 <2.0.0" – multiple constraints (space-separated, all must match)
+ *
+ * Returns true if compatible, false if not, and true for empty/undefined
+ * ranges (no constraint = always compatible).
+ */
+export declare function checkCompatibility(range: string | undefined): boolean;
+/** Parse a version string ("1.2.3") into [major, minor, patch]. */
+export declare function parseVersion(version: string): [number, number, number] | null;
+/**
+ * Check if a version string satisfies a range expression.
+ * Space-separated constraints are ANDed together.
+ */
+export declare function satisfiesRange(versionStr: string, range: string): boolean;
+export { readPluginManifest as _readPluginManifest, isMonorepo as _isMonorepo, getEnabledPlugins as _getEnabledPlugins, checkCompatibility as _checkCompatibility, parseVersion as _parseVersion, satisfiesRange as _satisfiesRange, };

package/dist/src/plugin-manifest.js

@@ -0,0 +1,160 @@
+/**
+ * Plugin manifest: reads and validates webcmd-plugin.json files.
+ *
+ * Supports two modes:
+ * 1. Single plugin: repo root IS the plugin directory.
+ * 2. Monorepo: repo contains multiple plugins declared in `plugins` field.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { PKG_VERSION } from './version.js';
+export const MANIFEST_FILENAME = 'webcmd-plugin.json';
+// ── Read / Validate ─────────────────────────────────────────────────────────
+/**
+ * Read and parse webcmd-plugin.json from a directory.
+ * Returns null if the file does not exist or is unparseable.
+ */
+export function readPluginManifest(dir) {
+    const manifestPath = path.join(dir, MANIFEST_FILENAME);
+    try {
+        const raw = fs.readFileSync(manifestPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/** Returns true when the manifest declares a monorepo (has `plugins` field). */
+export function isMonorepo(manifest) {
+    return (manifest.plugins !== undefined &&
+        manifest.plugins !== null &&
+        typeof manifest.plugins === 'object' &&
+        Object.keys(manifest.plugins).length > 0);
+}
+/**
+ * Get the list of enabled sub-plugins from a monorepo manifest.
+ * Returns entries sorted by key name.
+ */
+export function getEnabledPlugins(manifest) {
+    if (!manifest.plugins)
+        return [];
+    return Object.entries(manifest.plugins)
+        .filter(([, entry]) => !entry.disabled)
+        .map(([name, entry]) => ({ name, entry }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+// ── Version compatibility ───────────────────────────────────────────────────
+/**
+ * Check if the current webcmd version satisfies a semver range string.
+ *
+ * Supports a simplified subset of semver ranges:
+ *   ">=1.0.0"   – greater than or equal
+ *   "<=1.5.0"   – less than or equal
+ *   ">1.0.0"    – strictly greater
+ *   "<2.0.0"    – strictly less
+ *   "^1.2.0"    – compatible (>=1.2.0 and <2.0.0)
+ *   "~1.2.0"    – patch-level (>=1.2.0 and <1.3.0)
+ *   "1.2.0"     – exact match
+ *   ">=1.0.0 <2.0.0" – multiple constraints (space-separated, all must match)
+ *
+ * Returns true if compatible, false if not, and true for empty/undefined
+ * ranges (no constraint = always compatible).
+ */
+export function checkCompatibility(range) {
+    if (!range || range.trim() === '')
+        return true;
+    return satisfiesRange(PKG_VERSION, range);
+}
+/** Parse a version string ("1.2.3") into [major, minor, patch]. */
+export function parseVersion(version) {
+    const match = version.trim().match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!match)
+        return null;
+    return [parseInt(match[1], 10), parseInt(match[2], 10), parseInt(match[3], 10)];
+}
+/** Compare two version tuples: -1 if a<b, 0 if equal, 1 if a>b. */
+function compareVersions(a, b) {
+    for (let i = 0; i < 3; i++) {
+        if (a[i] < b[i])
+            return -1;
+        if (a[i] > b[i])
+            return 1;
+    }
+    return 0;
+}
+/** Check if a version satisfies a single constraint like ">=1.2.0". */
+function satisfiesSingleConstraint(version, constraint) {
+    const trimmed = constraint.trim();
+    if (!trimmed)
+        return true;
+    // ^1.2.0 → >=1.2.0 <2.0.0
+    if (trimmed.startsWith('^')) {
+        const target = parseVersion(trimmed.slice(1));
+        if (!target)
+            return true;
+        const upper = [target[0] + 1, 0, 0];
+        return compareVersions(version, target) >= 0 && compareVersions(version, upper) < 0;
+    }
+    // ~1.2.0 → >=1.2.0 <1.3.0
+    if (trimmed.startsWith('~')) {
+        const target = parseVersion(trimmed.slice(1));
+        if (!target)
+            return true;
+        const upper = [target[0], target[1] + 1, 0];
+        return compareVersions(version, target) >= 0 && compareVersions(version, upper) < 0;
+    }
+    // >=, <=, >, <, =
+    if (trimmed.startsWith('>=')) {
+        const target = parseVersion(trimmed.slice(2));
+        if (!target)
+            return true;
+        return compareVersions(version, target) >= 0;
+    }
+    if (trimmed.startsWith('<=')) {
+        const target = parseVersion(trimmed.slice(2));
+        if (!target)
+            return true;
+        return compareVersions(version, target) <= 0;
+    }
+    if (trimmed.startsWith('>')) {
+        const target = parseVersion(trimmed.slice(1));
+        if (!target)
+            return true;
+        return compareVersions(version, target) > 0;
+    }
+    if (trimmed.startsWith('<')) {
+        const target = parseVersion(trimmed.slice(1));
+        if (!target)
+            return true;
+        return compareVersions(version, target) < 0;
+    }
+    if (trimmed.startsWith('=')) {
+        const target = parseVersion(trimmed.slice(1));
+        if (!target)
+            return true;
+        return compareVersions(version, target) === 0;
+    }
+    // Exact match
+    const target = parseVersion(trimmed);
+    if (!target)
+        return true;
+    return compareVersions(version, target) === 0;
+}
+/**
+ * Check if a version string satisfies a range expression.
+ * Space-separated constraints are ANDed together.
+ */
+export function satisfiesRange(versionStr, range) {
+    const version = parseVersion(versionStr);
+    if (!version)
+        return true; // Can't parse our own version → assume ok
+    // Split on whitespace for multi-constraint ranges (e.g. ">=1.0.0 <2.0.0")
+    const constraints = range.trim().split(/\s+/);
+    return constraints.every((c) => satisfiesSingleConstraint(version, c));
+}
+// ── Exports for testing ─────────────────────────────────────────────────────
+export { readPluginManifest as _readPluginManifest, isMonorepo as _isMonorepo, getEnabledPlugins as _getEnabledPlugins, checkCompatibility as _checkCompatibility, parseVersion as _parseVersion, satisfiesRange as _satisfiesRange, };

package/dist/src/plugin-manifest.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for plugin manifest: reading, validating, and compatibility checks.
+ */
+export {};