@windagency/valora-plugin-compression-typescript 1.0.0

package/README.md

@@ -0,0 +1,26 @@
+# @windagency/valora-plugin-compression-typescript
+
+Output-compression strategies for the TypeScript / JavaScript ecosystem.
+
+## Install
+
+```bash
+valora plugin add compression-typescript
+```
+
+Depends on `valora-plugin-compression-universal` (declared via `requires`).
+
+## What it contributes
+
+Registers 12 compression strategies via `api.compression.registerStrategy`: `tsc`, `eslint`, `jest`, `vitest`, `pnpm`, `npm`, `npx`, `yarn`, `prettier`, `bun`, `bunx`, `biome`.
+
+Each strategy is a pure string-transform that strips redundant lines (e.g. tsc's repeated file paths, eslint's per-rule headers) before output is added to the LLM context.
+
+## Permissions
+
+`code-exec` — required by the loader to register a `code` contribution.
+
+## See also
+
+- [Plugins user guide](../../documentation/user-guide/plugins.md)
+- [Writing plugins](../../documentation/developer-guide/writing-plugins.md)

package/dist/index.js

@@ -0,0 +1,15 @@
+import { filterBiome, filterEslint, filterPackageManager, filterPrettier, filterTestRunner, filterTsc } from './strategies.js';
+export function register(api) {
+    api.compression.registerStrategy('tsc', filterTsc);
+    api.compression.registerStrategy('eslint', filterEslint);
+    api.compression.registerStrategy('jest', filterTestRunner);
+    api.compression.registerStrategy('vitest', filterTestRunner);
+    api.compression.registerStrategy('pnpm', filterPackageManager);
+    api.compression.registerStrategy('npm', filterPackageManager);
+    api.compression.registerStrategy('npx', filterPackageManager);
+    api.compression.registerStrategy('yarn', filterPackageManager);
+    api.compression.registerStrategy('prettier', filterPrettier);
+    api.compression.registerStrategy('bun', filterPackageManager);
+    api.compression.registerStrategy('bunx', filterPackageManager);
+    api.compression.registerStrategy('biome', filterBiome);
+}

package/dist/strategies.js

@@ -0,0 +1,264 @@
+const TSC_MAX_EXAMPLES_PER_CODE = 3;
+const ESLINT_MAX_EXAMPLES_PER_RULE = 2;
+const BIOME_MAX_EXAMPLES_PER_RULE = 2;
+export function filterBiome(output, _command) {
+    const lines = output.split('\n');
+    const byRule = new Map();
+    const other = [];
+    let inBlock = false;
+    for (const line of lines) {
+        if (addBiomeViolation(byRule, line)) {
+            inBlock = true;
+            continue;
+        }
+        if (inBlock) {
+            if (line && !/^\s/.test(line)) {
+                inBlock = false;
+                other.push(line);
+            }
+            continue;
+        }
+        other.push(line);
+    }
+    return [...other, ...[...byRule.values()].flat()].join('\n');
+}
+export function filterEslint(output, _command) {
+    const lines = output.split('\n');
+    const byRule = new Map();
+    const other = [];
+    for (const line of lines) {
+        const match = line.match(/^\s+\d+:\d+\s+(error|warning)\s+(\S+)/);
+        if (match) {
+            const rule = match[2] ?? '';
+            const bucket = byRule.get(rule);
+            if (!bucket) {
+                byRule.set(rule, [line]);
+            }
+            else if (bucket.length < ESLINT_MAX_EXAMPLES_PER_RULE) {
+                bucket.push(line);
+            }
+            else if (bucket.length === ESLINT_MAX_EXAMPLES_PER_RULE) {
+                bucket.push(`  ... (more ${rule} violations)`);
+            }
+        }
+        else {
+            other.push(line);
+        }
+    }
+    return [...other, ...[...byRule.values()].flat()].join('\n');
+}
+export function filterPackageManager(output, _command) {
+    const lines = output.split('\n');
+    const result = [];
+    let addedCount = 0;
+    const flushAdded = () => {
+        if (addedCount > 0) {
+            result.push(`[${addedCount} packages added]`);
+            addedCount = 0;
+        }
+    };
+    for (const line of lines) {
+        if (isPackageManagerNoise(line))
+            continue;
+        if (/^\+ \S+@\S+/.test(line)) {
+            addedCount++;
+            continue;
+        }
+        flushAdded();
+        result.push(line);
+    }
+    flushAdded();
+    return result.join('\n');
+}
+export function filterPrettier(output, _command) {
+    return output
+        .split('\n')
+        .filter((line) => !/^Checking formatting\.\.\./.test(line))
+        .join('\n');
+}
+export function filterTestRunner(output, _command) {
+    const lines = collapseCoverageTables(output.split('\n'));
+    const kept = [];
+    let passCount = 0;
+    const flushPassCount = () => {
+        if (passCount > 0) {
+            kept.push(`[${passCount} test suite${passCount === 1 ? '' : 's'} passed]`);
+            passCount = 0;
+        }
+    };
+    for (const line of lines) {
+        const isPassLine = /^\s*(✓|PASS\b|passed\b)/.test(line);
+        const isFailLine = /^\s*(✗|✕|FAIL\b|×)/.test(line);
+        const isSummaryLine = /^(Tests?|Test Files?|Suites?|Duration|Time|Ran all)/.test(line);
+        if (isFailLine) {
+            flushPassCount();
+            kept.push(line);
+        }
+        else if (isPassLine) {
+            passCount++;
+        }
+        else if (isSummaryLine) {
+            flushPassCount();
+            kept.push(line);
+        }
+        else {
+            kept.push(line);
+        }
+    }
+    flushPassCount();
+    return kept.join('\n');
+}
+export function filterTsc(output, _command) {
+    let lines = output.split('\n');
+    if (lines.some((l) => /^\[\d+:\d+:\d+ [AP]M\]/.test(l)))
+        lines = extractLastWatchCycle(lines);
+    if (lines.some((l) => /^={8} Resolving module /.test(l)))
+        lines = foldTraceResolution(lines);
+    const errorsByCode = new Map();
+    const other = [];
+    for (const line of lines) {
+        if (isCodeFrameLine(line))
+            continue;
+        const match = line.match(/: (error|warning) (TS\d+):/);
+        if (match) {
+            const code = match[2] ?? '';
+            const bucket = errorsByCode.get(code);
+            if (!bucket) {
+                errorsByCode.set(code, [line]);
+            }
+            else if (bucket.length < TSC_MAX_EXAMPLES_PER_CODE) {
+                bucket.push(line);
+            }
+            else if (bucket.length === TSC_MAX_EXAMPLES_PER_CODE) {
+                bucket.push(`  ... (more ${code} errors)`);
+            }
+        }
+        else {
+            other.push(line);
+        }
+    }
+    return [...other, ...[...errorsByCode.values()].flat()].join('\n');
+}
+function addBiomeViolation(byRule, line) {
+    const m = line.match(/^(\S+:\d+:\d+)\s+(\S+)\s+━/);
+    if (!m)
+        return false;
+    const rule = m[2] ?? '';
+    const ruleShort = rule.split('/').pop() ?? rule;
+    const entry = `${m[1]} ${rule}`;
+    const bucket = byRule.get(ruleShort);
+    if (!bucket) {
+        byRule.set(ruleShort, [entry]);
+    }
+    else if (bucket.length < BIOME_MAX_EXAMPLES_PER_RULE) {
+        bucket.push(entry);
+    }
+    else if (bucket.length === BIOME_MAX_EXAMPLES_PER_RULE) {
+        bucket.push(`  ... (more ${ruleShort} violations)`);
+    }
+    return true;
+}
+function collapseCoverageTables(lines) {
+    const result = [];
+    let fileCount = 0;
+    let overall = '';
+    let inTable = false;
+    const flushTable = () => {
+        result.push(`[coverage: ${fileCount} files, overall ${overall}%]`);
+        fileCount = 0;
+        overall = '';
+        inTable = false;
+    };
+    for (const line of lines) {
+        if (/^\s*%\s*Coverage report/.test(line)) {
+            inTable = true;
+            continue;
+        }
+        if (!inTable) {
+            result.push(line);
+            continue;
+        }
+        if (isCoverageTableNoiseLine(line))
+            continue;
+        const allFilesMatch = line.match(/^All files\s*\|\s*([\d.]+)/);
+        if (allFilesMatch) {
+            overall = allFilesMatch[1] ?? '';
+            continue;
+        }
+        if (/^\s+\S/.test(line) && line.includes('|')) {
+            fileCount++;
+            continue;
+        }
+        flushTable();
+        result.push(line);
+    }
+    if (inTable)
+        flushTable();
+    return result;
+}
+function extractLastWatchCycle(lines) {
+    const MARKER = /^\[\d+:\d+:\d+ [AP]M\] (Starting compilation in watch mode|File change detected)/;
+    let lastIdx = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (MARKER.test(lines[i] ?? '')) {
+            lastIdx = i;
+            break;
+        }
+    }
+    return lastIdx >= 0 ? lines.slice(lastIdx) : lines;
+}
+function foldTraceResolution(lines) {
+    const result = [];
+    let inBlock = false;
+    for (const line of lines) {
+        if (/^={8} Resolving module /.test(line)) {
+            inBlock = true;
+            continue;
+        }
+        if (/^={8} Module name /.test(line)) {
+            result.push(line);
+            inBlock = false;
+            continue;
+        }
+        if (!inBlock)
+            result.push(line);
+    }
+    return result;
+}
+function isCodeFrameLine(line) {
+    if (/^\s*\d+\s/.test(line))
+        return true;
+    if (/^\s*[~^]+\s*$/.test(line))
+        return true;
+    return false;
+}
+function isCoverageTableNoiseLine(line) {
+    if (/^-+\|/.test(line))
+        return true;
+    if (/^-+/.test(line.trim()))
+        return true;
+    if (/File\s+\|/.test(line))
+        return true;
+    return false;
+}
+function isPackageManagerNoise(line) {
+    if (/^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/.test(line))
+        return true;
+    if (/^Progress:/.test(line))
+        return true;
+    if (/^npm warn/i.test(line))
+        return true;
+    if (/^warning /i.test(line))
+        return true;
+    if (/^warning ".+ >/.test(line))
+        return true;
+    if (/^found \d+ vulnerabilit/i.test(line))
+        return true;
+    if (/^npm notice/i.test(line))
+        return true;
+    if (/\d+\s+packages?\s+are?\s+looking\s+for\s+funding/i.test(line))
+        return true;
+    if (/npm\s+fund/i.test(line))
+        return true;
+    return false;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@windagency/valora-plugin-compression-typescript",
+  "version": "1.0.0",
+  "description": "Compression strategies for the TypeScript/JavaScript ecosystem: tsc, eslint, jest, vitest, pnpm, npm, npx, yarn.",
+  "keywords": [
+    "valora",
+    "valora-plugin",
+    "compression",
+    "typescript",
+    "eslint",
+    "vitest",
+    "jest"
+  ],
+  "author": "Damien TIVELET <damien@wind-agency.com>",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "volta": {
+    "node": "22.21.0",
+    "pnpm": "10.19.0"
+  },
+  "files": [
+    "valora-plugin.json",
+    "dist"
+  ],
+  "peerDependencies": {
+    "@windagency/valora": ">=0.1.0"
+  },
+  "devDependencies": {
+    "vitest": "^1.0.0",
+    "@windagency/valora-plugin-api": "1.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf ./dist",
+    "lint": "eslint --color",
+    "lint:fix": "eslint --color --fix",
+    "beautify": "prettier --check \"**/*.+(js|jsx|ts|tsx|json|md|yml|yaml)\"",
+    "beautify:fix": "prettier --write \"**/*.+(js|jsx|ts|tsx|json|md|yml|yaml)\"",
+    "format": "pnpm beautify:fix && pnpm lint:fix",
+    "test": "vitest run"
+  }
+}

package/valora-plugin.json

@@ -0,0 +1,10 @@
+{
+	"name": "valora-plugin-compression-typescript",
+	"version": "1.0.0",
+	"description": "Compression strategies for the TypeScript/JavaScript ecosystem: tsc, eslint, jest, vitest, pnpm, npm, npx, yarn, prettier, bun, bunx, biome (12 strategies).",
+	"engines": { "valora": ">=0.1.0" },
+	"contributes": ["code"],
+	"permissions": ["code-exec"],
+	"requires": ["valora-plugin-compression-universal"],
+	"codeEntrypoint": "dist/index.js"
+}