@entelligentsia/forgecli 1.0.2 → 1.0.10

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"
+  }
+}

package/node_modules/@entelligentsia/forge-compress/src/__tests__/compress.test.ts

@@ -0,0 +1,409 @@
+import { describe, it, expect } from "vitest";
+import {
+  compressStoreQuery,
+  compressEntity,
+  compressEntityList,
+  compressMarkdown,
+  compressValidateStore,
+  countTokens,
+  compressIb,
+  compressProgressive,
+  truncateToTokenBudget,
+  lightweightCleanup,
+  verbatimCompact,
+  stripAnsi,
+} from "../index.js";
+
+// ── store-query compressor ──────────────────────────────────
+
+const SAMPLE_QUERY = JSON.stringify(
+  {
+    query: "open tasks in S12",
+    path: "intent-nlp",
+    traversalTrace: [
+      "parsed intent: entity=task, status=open, sprint=S12",
+      "resolved S12 → PROJ-S12",
+      "loaded 8 task records",
+      "filtered by status: 5 matched",
+    ],
+    results: [
+      {
+        id: "PROJ-S12-T01",
+        title: "Add auth middleware",
+        status: "implementing",
+        type: "task",
+        relationships: { sprintId: "PROJ-S12", featureId: "F-AUTH", blockedBy: null },
+        fileRefs: { json: ".forge/store/tasks/PROJ-S12-T01.json", md: ".forge/sprints/S12/tasks/T01/INDEX.md" },
+        storeRef: ".forge/store/tasks/PROJ-S12-T01.json",
+        indexRef: ".forge/sprints/S12/tasks/T01/INDEX.md",
+        excerpt: "# T01: Add auth middleware\n\n## Status: implementing\n\n## Plan\nImplement JWT-based auth middleware...\n\n## Key Changes\n- Added middleware handler\n- Updated route config\n- Added token validation\n\n## Notes\nBlocked by upstream API changes.\nNeed to coordinate with team B.\nAlso requires DB migration.\nSee PR #42 for details.\nReviewed by @alice.",
+      },
+      {
+        id: "PROJ-S12-T02",
+        title: "Fix rate limiter",
+        status: "planned",
+        type: "task",
+        relationships: { sprintId: "PROJ-S12" },
+        fileRefs: { json: ".forge/store/tasks/PROJ-S12-T02.json", md: ".forge/sprints/S12/tasks/T02/INDEX.md" },
+        storeRef: ".forge/store/tasks/PROJ-S12-T02.json",
+        indexRef: ".forge/sprints/S12/tasks/T02/INDEX.md",
+        excerpt: "# T02: Fix rate limiter\n\n## Status: planned\n\nRate limiter is dropping legitimate requests under load.",
+      },
+    ],
+    relatedFileRefs: [".forge/sprints/S12/INDEX.md", ".forge/features/F-AUTH.md"],
+    config: { store: ".forge/store", engineering: ".forge/engineering" },
+    meta: { mode: "intent-nlp", engineVersion: "1.2.0", totalTimeMs: 42 },
+  },
+  null,
+  2,
+);
+
+describe("compressStoreQuery", () => {
+  it("strips envelope fields", () => {
+    const result = compressStoreQuery(SAMPLE_QUERY);
+    const parsed = JSON.parse(result);
+    expect(parsed.traversalTrace).toBeUndefined();
+    expect(parsed.config).toBeUndefined();
+    expect(parsed.meta).toBeUndefined();
+    expect(parsed.relatedFileRefs).toBeUndefined();
+    expect(parsed.results).toHaveLength(2);
+  });
+
+  it("strips fileRefs and storeRef from results", () => {
+    const result = compressStoreQuery(SAMPLE_QUERY);
+    const parsed = JSON.parse(result);
+    expect(parsed.results[0].fileRefs).toBeUndefined();
+    expect(parsed.results[0].storeRef).toBeUndefined();
+    expect(parsed.results[0].indexRef).toBeUndefined();
+  });
+
+  it("strips excerpts by default", () => {
+    const result = compressStoreQuery(SAMPLE_QUERY);
+    const parsed = JSON.parse(result);
+    expect(parsed.results[0].excerpt).toBeUndefined();
+  });
+
+  it("keeps truncated excerpts when requested", () => {
+    const result = compressStoreQuery(SAMPLE_QUERY, {
+      keepExcerpts: true,
+      maxExcerptLines: 3,
+    });
+    const parsed = JSON.parse(result);
+    expect(parsed.results[0].excerpt).toContain("Add auth middleware");
+    expect(parsed.results[0].excerpt).toContain("more lines");
+  });
+
+  it("preserves query and path", () => {
+    const result = compressStoreQuery(SAMPLE_QUERY);
+    const parsed = JSON.parse(result);
+    expect(parsed.query).toBe("open tasks in S12");
+    expect(parsed.path).toBe("intent-nlp");
+  });
+
+  it("limits results count", () => {
+    const result = compressStoreQuery(SAMPLE_QUERY, { maxResults: 1 });
+    const parsed = JSON.parse(result);
+    expect(parsed.results).toHaveLength(1);
+    expect(parsed.truncated).toBe(1);
+  });
+
+  it("strips null relationships", () => {
+    const result = compressStoreQuery(SAMPLE_QUERY);
+    const parsed = JSON.parse(result);
+    expect(parsed.results[0].relationships.blockedBy).toBeUndefined();
+  });
+
+  it("is significantly smaller than input", () => {
+    const result = compressStoreQuery(SAMPLE_QUERY);
+    expect(countTokens(result)).toBeLessThan(countTokens(SAMPLE_QUERY) * 0.5);
+  });
+
+  it("passes through non-JSON input", () => {
+    expect(compressStoreQuery("not json")).toBe("not json");
+  });
+});
+
+// ── entity compressor ───────────────────────────────────────
+
+const SAMPLE_TASK = JSON.stringify(
+  {
+    taskId: "PROJ-S12-T01",
+    sprintId: "PROJ-S12",
+    title: "Add auth middleware",
+    status: "implementing",
+    path: "sprints/S12/tasks/T01",
+    feature_id: "F-AUTH",
+    description: "Implement JWT-based authentication middleware for all API routes.",
+    estimate: "M",
+    dependencies: ["PROJ-S12-T03"],
+    knowledgeUpdates: [{ file: "auth.md", delta: "Added JWT flow" }],
+    planIterations: 2,
+    codeReviewIterations: 1,
+    assignedModel: "claude-opus-4-7",
+    pipeline: "standard",
+    summaries: {
+      plan: {
+        objective: "Design JWT middleware architecture",
+        written_at: "2026-05-20T10:00:00Z",
+        key_changes: ["Created middleware handler", "Updated route config", "Added token validation", "Set up refresh flow"],
+        findings: ["Need to handle expired tokens gracefully"],
+        verdict: "approved",
+        artifact_ref: "PLAN.md",
+      },
+      review_plan: {
+        objective: "Review plan for auth middleware",
+        written_at: "2026-05-20T14:00:00Z",
+        key_changes: ["Approved with minor suggestions"],
+        verdict: "approved",
+      },
+      implementation: {
+        objective: "Implement auth middleware per plan",
+        written_at: "2026-05-21T09:00:00Z",
+        key_changes: ["Implemented JWT parsing", "Added route guards", "Unit tests passing", "Integration tests added", "Error handling complete"],
+        verdict: "approved",
+        artifact_ref: "PROGRESS.md",
+      },
+    },
+  },
+  null,
+  2,
+);
+
+describe("compressEntity", () => {
+  it("keeps essential fields", () => {
+    const result = compressEntity(SAMPLE_TASK);
+    const parsed = JSON.parse(result);
+    expect(parsed.taskId).toBe("PROJ-S12-T01");
+    expect(parsed.title).toBe("Add auth middleware");
+    expect(parsed.status).toBe("implementing");
+    expect(parsed.sprintId).toBe("PROJ-S12");
+  });
+
+  it("drops verbose fields by default", () => {
+    const result = compressEntity(SAMPLE_TASK);
+    const parsed = JSON.parse(result);
+    expect(parsed.description).toBeUndefined();
+    expect(parsed.knowledgeUpdates).toBeUndefined();
+    expect(parsed.assignedModel).toBeUndefined();
+    expect(parsed.path).toBeUndefined();
+    expect(parsed.planIterations).toBeUndefined();
+  });
+
+  it("keeps only latest summary by default", () => {
+    const result = compressEntity(SAMPLE_TASK);
+    const parsed = JSON.parse(result);
+    expect(parsed.summaries).toBeUndefined();
+    expect(parsed.latestPhase).toBe("implementation");
+    expect(parsed.latestSummary.objective).toBe("Implement auth middleware per plan");
+    expect(parsed.latestSummary.verdict).toBe("approved");
+  });
+
+  it("truncates key_changes in summary", () => {
+    const result = compressEntity(SAMPLE_TASK, { maxKeyChanges: 2 });
+    const parsed = JSON.parse(result);
+    expect(parsed.latestSummary.key_changes).toHaveLength(3);
+    expect(parsed.latestSummary.key_changes[2]).toContain("+3 more");
+  });
+
+  it("keeps all summaries when requested", () => {
+    const result = compressEntity(SAMPLE_TASK, { keepSummaries: "all" });
+    const parsed = JSON.parse(result);
+    expect(parsed.summaries).toBeDefined();
+    expect(parsed.summaries.plan).toBeDefined();
+    expect(parsed.summaries.implementation).toBeDefined();
+  });
+
+  it("produces flat format", () => {
+    const result = compressEntity(SAMPLE_TASK, { flatFormat: true });
+    expect(result).toContain("taskId: PROJ-S12-T01");
+    expect(result).toContain("status: implementing");
+    expect(result).not.toContain("{");
+  });
+
+  it("is smaller than input", () => {
+    const result = compressEntity(SAMPLE_TASK);
+    expect(countTokens(result)).toBeLessThan(countTokens(SAMPLE_TASK) * 0.5);
+  });
+});
+
+describe("compressEntityList", () => {
+  it("compresses array of entities", () => {
+    const list = JSON.stringify([JSON.parse(SAMPLE_TASK), JSON.parse(SAMPLE_TASK)], null, 2);
+    const result = compressEntityList(list);
+    const parsed = JSON.parse(result);
+    expect(parsed).toHaveLength(2);
+    expect(parsed[0].taskId).toBe("PROJ-S12-T01");
+    expect(parsed[0].description).toBeUndefined();
+  });
+});
+
+// ── markdown compressor ─────────────────────────────────────
+
+const SAMPLE_MD = `---
+title: Sprint S12 Progress
+date: 2026-05-25
+---
+
+# Sprint S12: Auth & Rate Limiting
+
+## Overview
+This sprint covers the implementation of JWT authentication
+middleware and fixing the rate limiter under high load.
+There are multiple sub-tasks involved.
+
+## Tasks
+
+### T01: Add auth middleware
+- **Status**: implementing
+- **Estimate**: M
+- Started implementation on May 20th
+- Plan was approved after 2 iterations
+- Currently blocked on upstream API
+
+### T02: Fix rate limiter
+- **Status**: planned
+- **Estimate**: S
+- Root cause identified as connection pool exhaustion
+
+## Risks
+- Upstream API team may not deliver on time
+- Rate limiter fix requires load testing infrastructure
+- JWT library has a known CVE that needs patching
+
+## Timeline
+| Milestone | Date | Status |
+|-----------|------|--------|
+| Plan approval | May 20 | Done |
+| Auth impl | May 25 | In progress |
+| Rate limiter | May 28 | Not started |
+`;
+
+describe("compressMarkdown", () => {
+  it("map mode keeps headings and key lines", () => {
+    const result = compressMarkdown(SAMPLE_MD, { mode: "map" });
+    expect(result).toContain("# Sprint S12");
+    expect(result).toContain("### T01");
+    expect(result).toContain("### T02");
+    expect(result).toContain("**Status**");
+    expect(result).toContain("body lines omitted");
+    expect(countTokens(result)).toBeLessThan(countTokens(SAMPLE_MD) * 0.7);
+  });
+
+  it("headings mode extracts structure only", () => {
+    const result = compressMarkdown(SAMPLE_MD, { mode: "headings" });
+    expect(result).toContain("Sprint S12");
+    expect(result).toContain("T01: Add auth middleware");
+    expect(result).toContain("sections");
+    expect(result).not.toContain("implementing");
+  });
+
+  it("truncate mode respects token budget", () => {
+    const result = compressMarkdown(SAMPLE_MD, { mode: "truncate", maxTokens: 50 });
+    expect(countTokens(result)).toBeLessThanOrEqual(60);
+  });
+
+  it("skips frontmatter", () => {
+    const result = compressMarkdown(SAMPLE_MD, { mode: "map" });
+    expect(result).not.toContain("title: Sprint S12 Progress");
+    expect(result).not.toContain("date: 2026");
+  });
+
+  it("handles empty input", () => {
+    expect(compressMarkdown("")).toBe("");
+    expect(compressMarkdown("   ")).toBe("");
+  });
+});
+
+// ── validate-store compressor ───────────────────────────────
+
+describe("compressValidateStore", () => {
+  it("compresses JSON report", () => {
+    const report = JSON.stringify({
+      ok: false,
+      errors: [
+        { entity: "task", id: "PROJ-S12-T01", category: "missing-required", field: "title", message: "title is required" },
+        { entity: "task", id: "PROJ-S12-T02", category: "missing-required", field: "status", message: "status is required" },
+        { entity: "bug", id: "PROJ-B01", category: "orphaned-fk", field: "sprintId", message: "references non-existent sprint" },
+      ],
+      warnings: [
+        { entity: "task", id: "PROJ-S12-T03", category: "stale-path", message: "path does not match filesystem" },
+      ],
+      fixes: [
+        { entity: "task", id: "PROJ-S12-T01", category: "backfill", message: "backfilled path", applied: true },
+      ],
+      summary: { sprints: 2, tasks: 5, bugs: 1, features: 0, errors: 3, warnings: 1, fixes: 1 },
+    });
+    const result = compressValidateStore(report);
+    expect(result).toContain("missing-required (2)");
+    expect(result).toContain("orphaned-fk (1)");
+    expect(result).toContain("1 warnings");
+    expect(result).toContain("1 fixes (1 applied)");
+    expect(countTokens(result)).toBeLessThan(countTokens(report) * 0.6);
+  });
+
+  it("returns ok for valid store", () => {
+    const report = JSON.stringify({
+      ok: true,
+      errors: [],
+      warnings: [],
+      fixes: [],
+      summary: { sprints: 3, tasks: 12, bugs: 2, features: 1, errors: 0, warnings: 0, fixes: 0 },
+    });
+    const result = compressValidateStore(report);
+    expect(result).toContain("3 sprints");
+    expect(result).toContain("12 tasks");
+  });
+
+  it("compresses plain text validation output", () => {
+    const lines = Array.from({ length: 20 }, (_, i) =>
+      `ERROR  PROJ-S12-T${String(i).padStart(2, "0")}: missing required field`
+    ).join("\n");
+    const result = compressValidateStore(lines);
+    expect(result).toContain("20 errors");
+    expect(result).toContain("... +15 more");
+  });
+});
+
+// ── core utilities ──────────────────────────────────────────
+
+describe("core utilities", () => {
+  it("countTokens", () => {
+    expect(countTokens("")).toBe(0);
+    expect(countTokens("hello world")).toBeGreaterThan(0);
+  });
+
+  it("stripAnsi", () => {
+    expect(stripAnsi("\x1b[31mERROR\x1b[0m")).toBe("ERROR");
+    expect(stripAnsi("clean")).toBe("clean");
+  });
+
+  it("truncateToTokenBudget", () => {
+    const long = "word ".repeat(1000);
+    const result = truncateToTokenBudget(long, 50);
+    expect(countTokens(result)).toBeLessThanOrEqual(60);
+  });
+
+  it("compressIb preserves high-entropy lines", () => {
+    let boring = "aaa bbb aaa bbb\n".repeat(30);
+    boring += "unique_identifier_xyz_quartz\n";
+    const result = compressIb(boring, 0.15);
+    expect(result).toContain("unique_identifier_xyz_quartz");
+  });
+
+  it("compressProgressive respects budget", () => {
+    const segs = Array.from({ length: 4 }, (_, i) => `segment ${i} content\n`);
+    const out = compressProgressive(segs, 80);
+    const total = out.reduce((acc, s) => acc + countTokens(s), 0);
+    expect(total).toBeLessThanOrEqual(80);
+  });
+
+  it("lightweightCleanup collapses blanks", () => {
+    const result = lightweightCleanup("a\n\n\n\n\nb");
+    expect(result.match(/\n/g)?.length ?? 0).toBeLessThanOrEqual(3);
+  });
+
+  it("verbatimCompact deduplicates", () => {
+    const result = verbatimCompact("same\n".repeat(20));
+    expect(result).toContain("[20x]");
+  });
+});