@entelligentsia/forgecli 1.0.2 → 1.0.3

package/node_modules/@entelligentsia/forge-compress/dist/forge/validate.js

@@ -0,0 +1,82 @@
+export function compressValidateStore(input) {
+    let report;
+    try {
+        report = JSON.parse(input);
+    }
+    catch {
+        return compressPlainValidation(input);
+    }
+    const errors = (report.errors ?? []);
+    const warnings = (report.warnings ?? []);
+    const fixes = (report.fixes ?? []);
+    const summary = report.summary;
+    const parts = [];
+    if (summary) {
+        const counts = Object.entries(summary)
+            .filter(([, v]) => v > 0)
+            .map(([k, v]) => `${v} ${k}`)
+            .join(", ");
+        if (counts)
+            parts.push(counts);
+    }
+    if (errors.length > 0) {
+        const grouped = groupBy(errors, "category");
+        for (const [cat, items] of Object.entries(grouped)) {
+            parts.push(`ERR ${cat} (${items.length}):`);
+            for (const item of items.slice(0, 5)) {
+                parts.push(`  ${item.id}: ${item.message}`);
+            }
+            if (items.length > 5)
+                parts.push(`  ... +${items.length - 5} more`);
+        }
+    }
+    if (warnings.length > 0) {
+        const grouped = groupBy(warnings, "category");
+        for (const [cat, items] of Object.entries(grouped)) {
+            parts.push(`WARN ${cat} (${items.length}):`);
+            for (const item of items.slice(0, 3)) {
+                parts.push(`  ${item.id}: ${item.message}`);
+            }
+            if (items.length > 3)
+                parts.push(`  ... +${items.length - 3} more`);
+        }
+    }
+    if (fixes.length > 0) {
+        const applied = fixes.filter((f) => f.applied).length;
+        parts.push(`${fixes.length} fixes (${applied} applied)`);
+    }
+    if (parts.length === 0)
+        return "ok (store valid)";
+    return parts.join("\n");
+}
+function compressPlainValidation(input) {
+    const lines = input.split("\n").filter((l) => l.trim());
+    if (lines.length <= 10)
+        return input;
+    const errors = lines.filter((l) => l.includes("ERROR"));
+    const warns = lines.filter((l) => l.includes("WARN"));
+    const fixed = lines.filter((l) => l.includes("FIXED"));
+    const parts = [];
+    if (errors.length > 0) {
+        parts.push(`${errors.length} errors:`);
+        for (const e of errors.slice(0, 5))
+            parts.push(`  ${e.trim()}`);
+        if (errors.length > 5)
+            parts.push(`  ... +${errors.length - 5} more`);
+    }
+    if (warns.length > 0)
+        parts.push(`${warns.length} warnings`);
+    if (fixed.length > 0)
+        parts.push(`${fixed.length} fixed`);
+    return parts.length > 0 ? parts.join("\n") : input;
+}
+function groupBy(items, key) {
+    const result = {};
+    for (const item of items) {
+        const k = String(item[key] ?? "unknown");
+        if (!result[k])
+            result[k] = [];
+        result[k].push(item);
+    }
+    return result;
+}

package/node_modules/@entelligentsia/forge-compress/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { compressStoreQuery, compressEntity, compressEntityList, compressMarkdown, compressValidateStore, } from "./forge/index.js";
+export type { CompressQueryOptions, CompressEntityOptions, CompressMarkdownOptions, } from "./forge/index.js";
+export { countTokens, truncateToTokenBudget } from "./tokens.js";
+export { compressIb } from "./entropy.js";
+export { compressProgressive } from "./progressive.js";
+export { lightweightCleanup, verbatimCompact, stripAnsi, } from "./compressor.js";

package/node_modules/@entelligentsia/forge-compress/dist/index.js

@@ -0,0 +1,5 @@
+export { compressStoreQuery, compressEntity, compressEntityList, compressMarkdown, compressValidateStore, } from "./forge/index.js";
+export { countTokens, truncateToTokenBudget } from "./tokens.js";
+export { compressIb } from "./entropy.js";
+export { compressProgressive } from "./progressive.js";
+export { lightweightCleanup, verbatimCompact, stripAnsi, } from "./compressor.js";

package/node_modules/@entelligentsia/forge-compress/dist/progressive.d.ts

@@ -0,0 +1 @@
+export declare function compressProgressive(segments: string[], budgetTokens: number): string[];

package/node_modules/@entelligentsia/forge-compress/dist/progressive.js

@@ -0,0 +1,108 @@
+import { truncateToTokenBudget } from "./tokens.js";
+const LAMBDA = 1.35;
+function expWeights(n) {
+    return Array.from({ length: n }, (_, i) => Math.exp(LAMBDA * i));
+}
+function allocateBudget(budgetTokens, weights) {
+    const n = weights.length;
+    if (n === 0 || budgetTokens === 0)
+        return new Array(n).fill(0);
+    const sumW = Math.max(weights.reduce((a, b) => a + b, 0), Number.EPSILON);
+    const base = new Array(n).fill(0);
+    const frac = new Array(n).fill(0);
+    for (let i = 0; i < n; i++) {
+        const exact = (budgetTokens * weights[i]) / sumW;
+        base[i] = Math.floor(exact);
+        frac[i] = exact - base[i];
+    }
+    const given = base.reduce((a, b) => a + b, 0);
+    const order = Array.from({ length: n }, (_, i) => i).sort((a, b) => frac[b] - frac[a]);
+    let extra = budgetTokens - given;
+    for (const i of order) {
+        if (extra <= 0)
+            break;
+        base[i]++;
+        extra--;
+    }
+    return base;
+}
+function tierForIndex(i, n) {
+    if (n <= 1)
+        return 2;
+    const r = i / (n - 1);
+    if (r < 1 / 3)
+        return 0;
+    if (r < 2 / 3)
+        return 1;
+    return 2;
+}
+const STRUCTURE_KEYWORDS = [
+    "fn ",
+    "pub ",
+    "struct ",
+    "enum ",
+    "trait ",
+    "impl ",
+    "mod ",
+    "use ",
+    "def ",
+    "class ",
+    "function ",
+    "export ",
+    "import ",
+    "const ",
+    "interface ",
+];
+function mapLike(s, maxTokens) {
+    const picked = [];
+    const lines = s.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        if (i === 0 || STRUCTURE_KEYWORDS.some((k) => lines[i].includes(k))) {
+            picked.push(lines[i]);
+        }
+        if (picked.length >= 48)
+            break;
+    }
+    if (picked.length === 0 && lines.length > 0) {
+        picked.push(lines[0]);
+    }
+    return truncateToTokenBudget(picked.join("\n"), Math.max(4, maxTokens));
+}
+function oneLineSummary(segIdx, s, maxTokens) {
+    const preview = s.split("\n")[0]?.slice(0, 120) ?? "";
+    const lineCount = s.split("\n").length;
+    const draft = `// seg[${segIdx}] ${lineCount} lines, ${s.length} chars | ${preview}`;
+    return truncateToTokenBudget(draft, Math.max(8, maxTokens));
+}
+export function compressProgressive(segments, budgetTokens) {
+    const n = segments.length;
+    if (n === 0)
+        return [];
+    if (budgetTokens === 0)
+        return segments.map(() => "");
+    const weights = expWeights(n);
+    const allocs = allocateBudget(budgetTokens, weights);
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        const alloc = allocs[i];
+        const tier = tierForIndex(i, n);
+        if (alloc === 0) {
+            out.push("");
+            continue;
+        }
+        let compressed;
+        switch (tier) {
+            case 2:
+                compressed = truncateToTokenBudget(segments[i], alloc);
+                break;
+            case 1:
+                compressed = mapLike(segments[i], alloc);
+                break;
+            default:
+                compressed = oneLineSummary(i, segments[i], alloc);
+                break;
+        }
+        out.push(truncateToTokenBudget(compressed, alloc));
+    }
+    return out;
+}

package/node_modules/@entelligentsia/forge-compress/dist/strip.d.ts

@@ -0,0 +1,4 @@
+export declare function stripAnsi(s: string): string;
+export declare function stripTimestampsAndHashes(line: string): string;
+export declare function normalizeWhitespace(line: string): string;
+export declare function isBoilerplate(line: string): boolean;

package/node_modules/@entelligentsia/forge-compress/dist/strip.js

@@ -0,0 +1,55 @@
+const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]/g;
+export function stripAnsi(s) {
+    if (!s.includes("\x1b"))
+        return s;
+    return s.replace(ANSI_RE, "");
+}
+const TS_RE = /\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?/g;
+const HASH_RE = /\b[0-9a-f]{32,64}\b/g;
+export function stripTimestampsAndHashes(line) {
+    return line.replace(TS_RE, "[TS]").replace(HASH_RE, "[HASH]");
+}
+export function normalizeWhitespace(line) {
+    let result = "";
+    let prevSpace = false;
+    for (const ch of line) {
+        if (ch === " " || ch === "\t") {
+            if (!prevSpace) {
+                result += " ";
+                prevSpace = true;
+            }
+        }
+        else {
+            result += ch;
+            prevSpace = false;
+        }
+    }
+    return result;
+}
+const BOILERPLATE_PREFIXES = [
+    "copyright",
+    "licensed under",
+    "license:",
+    "all rights reserved",
+    "generated by",
+    "auto-generated",
+];
+const SEPARATOR_CHARS = new Set(["=", "-", "*", "─", "━"]);
+export function isBoilerplate(line) {
+    const lower = line.toLowerCase();
+    if (BOILERPLATE_PREFIXES.some((p) => lower.startsWith(p)))
+        return true;
+    if (line.length >= 4) {
+        const first = line[0];
+        if (SEPARATOR_CHARS.has(first)) {
+            let same = 0;
+            for (const c of line) {
+                if (c === first)
+                    same++;
+            }
+            if (same / line.length > 0.8)
+                return true;
+        }
+    }
+    return false;
+}

package/node_modules/@entelligentsia/forge-compress/dist/tokens.d.ts

@@ -0,0 +1,2 @@
+export declare function countTokens(text: string): number;
+export declare function truncateToTokenBudget(text: string, maxTokens: number): string;

package/node_modules/@entelligentsia/forge-compress/dist/tokens.js

@@ -0,0 +1,17 @@
+const CHARS_PER_TOKEN = 3.7;
+export function countTokens(text) {
+    if (!text)
+        return 0;
+    return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+export function truncateToTokenBudget(text, maxTokens) {
+    if (maxTokens <= 0)
+        return "";
+    if (countTokens(text) <= maxTokens)
+        return text;
+    const charBudget = Math.floor(maxTokens * CHARS_PER_TOKEN);
+    const truncated = text.slice(0, charBudget);
+    const lastNewline = truncated.lastIndexOf("\n");
+    const clean = lastNewline > 0 ? truncated.slice(0, lastNewline) : truncated;
+    return `${clean} …`;
+}

package/node_modules/@entelligentsia/forge-compress/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@entelligentsia/forge-compress",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Entelligentsia/forge-compress.git"
+  },
+  "version": "0.1.0",
+  "description": "Token-efficient compression for Forge SDLC tool outputs — store queries, entities, artifacts",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "biome check src/",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "compression",
+    "forge",
+    "sdlc",
+    "ai-agent",
+    "token-reduction"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0",
+    "@biomejs/biome": "^1.9.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}