@entelligentsia/forgecli 1.0.2 → 1.0.10

package/node_modules/@entelligentsia/forge-compress/src/forge/validate.ts

@@ -0,0 +1,86 @@
+export function compressValidateStore(input: string): string {
+  let report: Record<string, unknown>;
+  try {
+    report = JSON.parse(input);
+  } catch {
+    return compressPlainValidation(input);
+  }
+
+  const errors = (report.errors ?? []) as { id: string; category: string; message: string }[];
+  const warnings = (report.warnings ?? []) as { id: string; category: string; message: string }[];
+  const fixes = (report.fixes ?? []) as { id: string; message: string; applied: boolean }[];
+  const summary = report.summary as Record<string, number> | undefined;
+
+  const parts: string[] = [];
+
+  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: string): string {
+  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: string[] = [];
+  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<T extends Record<string, unknown>>(
+  items: T[],
+  key: string,
+): Record<string, T[]> {
+  const result: Record<string, T[]> = {};
+  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/src/index.ts

@@ -0,0 +1,22 @@
+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/src/progressive.ts

@@ -0,0 +1,123 @@
+import { countTokens, truncateToTokenBudget } from "./tokens.js";
+
+const LAMBDA = 1.35;
+
+function expWeights(n: number): number[] {
+  return Array.from({ length: n }, (_, i) => Math.exp(LAMBDA * i));
+}
+
+function allocateBudget(budgetTokens: number, weights: number[]): number[] {
+  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: number, b: number) => 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: number, n: number): number {
+  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: string, maxTokens: number): string {
+  const picked: string[] = [];
+  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: number,
+  s: string,
+  maxTokens: number,
+): string {
+  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: string[],
+  budgetTokens: number,
+): string[] {
+  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: string[] = [];
+
+  for (let i = 0; i < n; i++) {
+    const alloc = allocs[i];
+    const tier = tierForIndex(i, n);
+    if (alloc === 0) {
+      out.push("");
+      continue;
+    }
+    let compressed: string;
+    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/src/strip.ts

@@ -0,0 +1,58 @@
+const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]/g;
+
+export function stripAnsi(s: string): string {
+  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: string): string {
+  return line.replace(TS_RE, "[TS]").replace(HASH_RE, "[HASH]");
+}
+
+export function normalizeWhitespace(line: string): string {
+  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: string): boolean {
+  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/src/tokens.ts

@@ -0,0 +1,19 @@
+const CHARS_PER_TOKEN = 3.7;
+
+export function countTokens(text: string): number {
+  if (!text) return 0;
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+
+export function truncateToTokenBudget(
+  text: string,
+  maxTokens: number,
+): string {
+  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/@mariozechner/clipboard/Cargo.toml

@@ -17,8 +17,8 @@ futures = "0.3.30"
 # Pin image to version compatible with older Rust in CI Docker images
 image = { version = "=0.25.5", features = ["png", "jpeg"], optional = true, default-features = false }
 # Default enable napi4 feature, see https://nodejs.org/api/n-api.html#node-api-version-matrix
-napi = { version = "2.12.2", default-features = false, features = ["napi4", "tokio_rt"] }
-napi-derive = "2.12.2"
+napi = { version = "3.9.0", default-features = false, features = ["napi4", "tokio_rt", "dyn-symbols"] }
+napi-derive = "3.5.6"
 tokio = "1.36.0"
 
 [target.'cfg(all(unix, not(any(target_os="macos", target_os="android", target_os="ios", target_os="emscripten"))))'.dependencies]
@@ -38,7 +38,7 @@ windows = { version = "0.59.0", features = ["Win32_Foundation", "Win32_Graphics_
 
 [build-dependencies]
 # Pin to version that works with older Rust in Docker images
-napi-build = "=2.1.3"
+napi-build = "2.3.2"
 
 [profile.release]
 lto = true

package/node_modules/@mariozechner/clipboard/index.d.ts

@@ -1,23 +1,37 @@
-/* tslint:disable */
+/* auto-generated by NAPI-RS */
 /* eslint-disable */
+export declare function availableFormats(): Array<string>
 
-/* auto-generated by NAPI-RS */
+export declare function callThreadsafeFunction(callback: ((err: Error | null, arg: number) => void)): void
+
+export declare function clear(): Promise<void>
+
+export declare function getHtml(): Promise<string>
+
+export declare function getImageBase64(): Promise<string>
+
+export declare function getImageBinary(): Promise<Array<number>>
+
+export declare function getRtf(): Promise<string>
+
+export declare function getText(): Promise<string>
+
+export declare function hasHtml(): boolean
+
+export declare function hasImage(): boolean
+
+export declare function hasRtf(): boolean
+
+export declare function hasText(): boolean
+
+export declare function setHtml(html: string): Promise<void>
+
+export declare function setImageBase64(base64Str: string): Promise<void>
+
+export declare function setImageBinary(imageBytes: Array<number>): Promise<void>
+
+export declare function setRtf(rtf: string): Promise<void>
+
+export declare function setText(text: string): Promise<void>
 
-export function availableFormats(): Array<string>
-export function getText(): Promise<string>
-export function setText(text: string): Promise<void>
-export function hasText(): boolean
-export function getImageBinary(): Promise<Array<number>>
-export function getImageBase64(): Promise<string>
-export function setImageBinary(imageBytes: Array<number>): Promise<void>
-export function setImageBase64(base64Str: string): Promise<void>
-export function hasImage(): boolean
-export function getHtml(): Promise<string>
-export function setHtml(html: string): Promise<void>
-export function hasHtml(): boolean
-export function getRtf(): Promise<string>
-export function setRtf(rtf: string): Promise<void>
-export function hasRtf(): boolean
-export function clear(): Promise<void>
-export function watch(): void
-export function callThreadsafeFunction(callback: (...args: any[]) => any): void
+export declare function watch(): void