little-coder 1.7.0 → 1.8.1

package/.pi/extensions/extra-tools/glob.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { globFiles, renderGlobOutcome, DEFAULT_HEAVY_DIRS } from "./glob.ts";
+
+let dir: string;
+
+beforeAll(() => {
+  dir = mkdtempSync(join(tmpdir(), "glob-test-"));
+  // real source we want to find
+  mkdirSync(join(dir, "src", "sub"), { recursive: true });
+  writeFileSync(join(dir, "src", "a.py"), "");
+  writeFileSync(join(dir, "src", "sub", "b.py"), "");
+  writeFileSync(join(dir, "README.md"), "");
+  // heavy dirs that must be pruned (with files matching the pattern inside)
+  mkdirSync(join(dir, "node_modules", "pkg", "deep"), { recursive: true });
+  writeFileSync(join(dir, "node_modules", "pkg", "deep", "x.py"), "");
+  mkdirSync(join(dir, ".git", "objects"), { recursive: true });
+  writeFileSync(join(dir, ".git", "objects", "y.py"), "");
+  mkdirSync(join(dir, "dist"), { recursive: true });
+  writeFileSync(join(dir, "dist", "z.py"), "");
+});
+
+afterAll(() => rmSync(dir, { recursive: true, force: true }));
+
+describe("globFiles", () => {
+  it("matches real files and prunes heavy dirs (node_modules/.git/dist)", async () => {
+    const { matches, scanTruncated, matchTruncated } = await globFiles("**/*.py", { base: dir });
+    const rel = matches.map((m) => m.slice(dir.length + 1)).sort();
+    expect(rel).toEqual(["src/a.py", "src/sub/b.py"]);
+    expect(matches.some((m) => m.includes("node_modules"))).toBe(false);
+    expect(matches.some((m) => m.includes(".git"))).toBe(false);
+    expect(matches.some((m) => m.includes("/dist/"))).toBe(false);
+    expect(scanTruncated).toBe(false);
+    expect(matchTruncated).toBe(false);
+  });
+
+  it("caps matches at maxMatches and flags matchTruncated", async () => {
+    const many = mkdtempSync(join(tmpdir(), "glob-many-"));
+    for (let i = 0; i < 50; i++) writeFileSync(join(many, `f${i}.txt`), "");
+    try {
+      const { matches, matchTruncated } = await globFiles("*.txt", { base: many, maxMatches: 10 });
+      expect(matches.length).toBe(10);
+      expect(matchTruncated).toBe(true);
+    } finally {
+      rmSync(many, { recursive: true, force: true });
+    }
+  });
+
+  it("stops the walk at maxScan and flags scanTruncated (memory bound)", async () => {
+    // A low budget must halt the walk regardless of how many entries exist.
+    const { scanned, scanTruncated } = await globFiles("**/*", { base: dir, maxScan: 3 });
+    expect(scanTruncated).toBe(true);
+    expect(scanned).toBeLessThanOrEqual(5); // a couple over the budget, not unbounded
+  });
+
+  it("the heavy-dir set covers the usual offenders", () => {
+    for (const d of ["node_modules", ".git", "dist", ".cache", "Library", "venv", "target"]) {
+      expect(DEFAULT_HEAVY_DIRS.has(d)).toBe(true);
+    }
+  });
+});
+
+describe("renderGlobOutcome", () => {
+  it("reports no matches plainly", () => {
+    expect(renderGlobOutcome({ matches: [], scanned: 5, scanTruncated: false, matchTruncated: false }))
+      .toBe("No files matched");
+  });
+  it("notes scan truncation when nothing matched", () => {
+    expect(renderGlobOutcome({ matches: [], scanned: 9, scanTruncated: true, matchTruncated: false }, 200000))
+      .toMatch(/stopped after scanning 200000 entries/);
+  });
+  it("appends a match-cap note", () => {
+    const text = renderGlobOutcome(
+      { matches: ["/a", "/b"], scanned: 2, scanTruncated: false, matchTruncated: true },
+      200000,
+      500,
+    );
+    expect(text).toMatch(/stopped at 500 matches/);
+  });
+  it("appends a scan-cap note when there were partial matches", () => {
+    const text = renderGlobOutcome(
+      { matches: ["/a"], scanned: 9, scanTruncated: true, matchTruncated: false },
+      200000,
+    );
+    expect(text).toMatch(/results may be incomplete/);
+  });
+});

package/.pi/extensions/extra-tools/glob.ts

@@ -0,0 +1,102 @@
+import { glob as fsGlob } from "node:fs/promises";
+
+// Bounded file globbing. The naive `for await (…glob…) { if (len>=500) break }`
+// only caps MATCHES — it does nothing about the WALK. Run from a huge root
+// (e.g. a home directory with macOS Library / caches / node_modules), fs.glob
+// recursively descends everything, and its internal traversal state grows until
+// the Node process OOMs (heap, not the model's context) — long before 500
+// matches are found if matches are sparse. fs.glob exposes no signal/abort and
+// no depth/scan cap, so we bound it through the one hook it does call for every
+// entry: `exclude`. We use it to (a) prune heavy/irrelevant directories so they
+// are never descended, and (b) meter total entries scanned — once the budget is
+// hit, exclude everything, which winds the walk down.
+
+/** Directories never worth descending for a file search — pruned at the dir
+ *  level (returning true from `exclude` on a directory stops descent), which is
+ *  what keeps a home-directory glob from exhausting memory. */
+export const DEFAULT_HEAVY_DIRS: ReadonlySet<string> = new Set([
+  // version control
+  ".git", ".hg", ".svn",
+  // dependencies / language caches
+  "node_modules", ".venv", "venv", "__pycache__", ".tox", ".mypy_cache",
+  ".pytest_cache", ".gradle", ".cargo", "vendor", "Pods",
+  // build output
+  "dist", "build", "out", "target", ".next", ".nuxt", ".output", ".svelte-kit",
+  // tool caches
+  ".cache", ".npm", ".pnpm-store", ".yarn", ".turbo",
+  // macOS / system heavies that blow up a home-dir walk
+  "Library", "Applications", ".Trash", "Photos Library.photoslibrary",
+]);
+
+export interface GlobOptions {
+  base: string;
+  maxScan?: number;
+  maxMatches?: number;
+  heavyDirs?: ReadonlySet<string>;
+}
+
+export interface GlobOutcome {
+  matches: string[];
+  scanned: number;
+  /** the walk was cut short at maxScan entries (results may be incomplete) */
+  scanTruncated: boolean;
+  /** matches were capped at maxMatches */
+  matchTruncated: boolean;
+}
+
+export const DEFAULT_MAX_SCAN = 200_000;
+export const DEFAULT_MAX_MATCHES = 500;
+
+export async function globFiles(pattern: string, opts: GlobOptions): Promise<GlobOutcome> {
+  const maxScan = opts.maxScan ?? DEFAULT_MAX_SCAN;
+  const maxMatches = opts.maxMatches ?? DEFAULT_MAX_MATCHES;
+  const heavy = opts.heavyDirs ?? DEFAULT_HEAVY_DIRS;
+
+  const matches: string[] = [];
+  let scanned = 0;
+  let scanTruncated = false;
+  let matchTruncated = false;
+
+  // Called for every entry the walk visits (files AND directories). Pruning a
+  // directory here stops descent into it. Also our scan meter: once the budget
+  // is spent, exclude everything so fs.glob stops adding work and ends.
+  const exclude = (entry: unknown): boolean => {
+    scanned++;
+    if (scanned > maxScan) {
+      scanTruncated = true;
+      return true;
+    }
+    const name = typeof entry === "string" ? entry : String((entry as { name?: string })?.name ?? entry);
+    return name.split(/[\\/]/).some((seg) => heavy.has(seg));
+  };
+
+  // `exclude` as a predicate isn't in every @types/node version's fs.glob
+  // signature, but it's supported at runtime (Node 22+); cast to pass it through.
+  for await (const m of fsGlob(pattern, { cwd: opts.base, exclude } as Parameters<typeof fsGlob>[1])) {
+    matches.push(`${opts.base}/${m}`);
+    if (matches.length >= maxMatches) {
+      matchTruncated = true;
+      break;
+    }
+  }
+
+  matches.sort();
+  return { matches, scanned, scanTruncated, matchTruncated };
+}
+
+/** Render a globFiles outcome as the tool's text output, with a one-line note
+ *  when results were cut short so the model knows to narrow its search. */
+export function renderGlobOutcome(o: GlobOutcome, maxScan = DEFAULT_MAX_SCAN, maxMatches = DEFAULT_MAX_MATCHES): string {
+  if (o.matches.length === 0) {
+    return o.scanTruncated
+      ? `No files matched (search stopped after scanning ${maxScan} entries — narrow the base path; build/dependency/cache dirs are skipped automatically).`
+      : "No files matched";
+  }
+  let text = o.matches.join("\n");
+  if (o.matchTruncated) {
+    text += `\n… (stopped at ${maxMatches} matches — narrow the pattern for the rest)`;
+  } else if (o.scanTruncated) {
+    text += `\n… (search stopped after scanning ${maxScan} entries — results may be incomplete; narrow the base path)`;
+  }
+  return text;
+}

package/.pi/extensions/extra-tools/index.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { glob as globSync } from "node:fs/promises";
+import { globFiles, renderGlobOutcome } from "./glob.ts";
 
 // Ports of tools.py::_glob, _webfetch, _websearch. Pi ships its own grep/find,
 // so those are not re-registered here.
@@ -10,7 +10,9 @@ export default function (pi: ExtensionAPI) {
     name: "glob",
     label: "Glob",
     description:
-      "Find files matching a glob pattern. Returns a sorted list of matching paths (up to 500).",
+      "Find files matching a glob pattern. Returns a sorted list of matching paths (up to 500). " +
+      "Common dependency/build/cache dirs (node_modules, .git, dist, …) are skipped, and the walk " +
+      "is bounded — for a focused search, pass a `path` rather than globbing a whole home directory.",
     parameters: Type.Object({
       pattern: Type.String({ description: "Glob pattern e.g. **/*.py" }),
       path: Type.Optional(Type.String({ description: "Base directory (default: cwd)" })),
@@ -18,16 +20,11 @@ export default function (pi: ExtensionAPI) {
     async execute(_id, { pattern, path }) {
       try {
         const base = path || process.cwd();
-        const matches: string[] = [];
-        // Node 22's fs/promises.glob — returns an async iterator
-        for await (const m of globSync(pattern, { cwd: base })) {
-          matches.push(`${base}/${m}`);
-          if (matches.length >= 500) break;
-        }
-        matches.sort();
-        const text = matches.length === 0 ? "No files matched" : matches.join("\n");
+        // Bounded walk: prunes heavy dirs and caps total entries scanned so a
+        // recursive glob from a huge root can't exhaust the process heap.
+        const outcome = await globFiles(pattern, { base });
         return {
-          content: [{ type: "text", text }],
+          content: [{ type: "text", text: renderGlobOutcome(outcome) }],
           details: {},
         };
       } catch (e) {

package/.pi/extensions/llama-cpp-provider/config.test.ts

@@ -3,7 +3,16 @@ import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { applyEnvOverrides, loadProviders, mergeProviders, resolveOverridePath, type ProviderEntry } from "./config.ts";
+import {
+  applyEnvOverrides,
+  loadProviders,
+  mergeProviders,
+  resolveOverridePath,
+  propsUrlFor,
+  contextWindowFromProps,
+  probeContextWindow,
+  type ProviderEntry,
+} from "./config.ts";
 
 const sampleProvider = (baseUrl: string, modelId: string): ProviderEntry => ({
   api: "openai-completions",
@@ -185,3 +194,65 @@ describe("shipped models.json", () => {
     expect(Object.keys(result.providers).sort()).toEqual(["llamacpp", "lmstudio", "ollama"]);
   });
 });
+
+describe("propsUrlFor", () => {
+  it("strips a trailing /v1 and points at the server root /props", () => {
+    expect(propsUrlFor("http://127.0.0.1:8888/v1")).toBe("http://127.0.0.1:8888/props");
+    expect(propsUrlFor("http://host:8888/v1/")).toBe("http://host:8888/props");
+    expect(propsUrlFor("http://host:8888")).toBe("http://host:8888/props");
+    expect(propsUrlFor("http://host:8888/")).toBe("http://host:8888/props");
+  });
+});
+
+describe("contextWindowFromProps", () => {
+  it("reads default_generation_settings.n_ctx (real llama.cpp shape)", () => {
+    expect(contextWindowFromProps({ default_generation_settings: { n_ctx: 131072 } })).toBe(131072);
+  });
+  it("falls back to a top-level n_ctx", () => {
+    expect(contextWindowFromProps({ n_ctx: 65536 })).toBe(65536);
+  });
+  it("returns undefined when absent or non-positive", () => {
+    expect(contextWindowFromProps({})).toBeUndefined();
+    expect(contextWindowFromProps({ default_generation_settings: { n_ctx: 0 } })).toBeUndefined();
+    expect(contextWindowFromProps({ default_generation_settings: { n_ctx: "lots" } })).toBeUndefined();
+    expect(contextWindowFromProps(null)).toBeUndefined();
+  });
+});
+
+describe("probeContextWindow", () => {
+  const okRes = (body: unknown) => ({ ok: true, json: async () => body }) as Response;
+
+  it("returns the server's n_ctx on success", async () => {
+    const fetchImpl = (async () =>
+      okRes({ default_generation_settings: { n_ctx: 131072 } })) as unknown as typeof fetch;
+    expect(await probeContextWindow("http://x:8888/v1", { fetchImpl })).toBe(131072);
+  });
+
+  it("returns undefined on a non-OK response", async () => {
+    const fetchImpl = (async () => ({ ok: false }) as Response) as unknown as typeof fetch;
+    expect(await probeContextWindow("http://x:8888/v1", { fetchImpl })).toBeUndefined();
+  });
+
+  it("returns undefined when fetch throws (server down / unreachable)", async () => {
+    const fetchImpl = (async () => {
+      throw new Error("ECONNREFUSED");
+    }) as unknown as typeof fetch;
+    expect(await probeContextWindow("http://x:8888/v1", { fetchImpl })).toBeUndefined();
+  });
+
+  it("returns undefined when the response lacks n_ctx", async () => {
+    const fetchImpl = (async () => okRes({ total_slots: 1 })) as unknown as typeof fetch;
+    expect(await probeContextWindow("http://x:8888/v1", { fetchImpl })).toBeUndefined();
+  });
+
+  it("honors an explicit props url override", async () => {
+    let seen = "";
+    const fetchImpl = (async (u: string) => {
+      seen = u;
+      return okRes({ default_generation_settings: { n_ctx: 40960 } });
+    }) as unknown as typeof fetch;
+    const got = await probeContextWindow("http://x:8888/v1", { fetchImpl, url: "http://other/props" });
+    expect(seen).toBe("http://other/props");
+    expect(got).toBe(40960);
+  });
+});

package/.pi/extensions/llama-cpp-provider/config.ts

@@ -146,3 +146,54 @@ export function loadProviders(pkgRoot: string, env: NodeJS.ProcessEnv = process.
   const withEnv = applyEnvOverrides(merged, env);
   return { providers: withEnv, sources };
 }
+
+// ── live context-window detection (llama.cpp /props) ────────────────────────
+// little-coder budgets against the model's registered contextWindow. Rather than
+// trust the static value in models.json, we ask a running llama.cpp server for
+// its actual n_ctx at startup, so a `-c 131072` server shows 128k instead of the
+// declared default. Best-effort: any failure falls back to the declared window.
+
+/** Derive the llama.cpp `/props` URL from an OpenAI-style baseUrl. llama-server
+ *  serves /props at the server ROOT, not under /v1 (which 404s), so strip a
+ *  trailing /v1 (and any trailing slash) before appending /props. */
+export function propsUrlFor(baseUrl: string): string {
+  const root = baseUrl.replace(/\/+$/, "").replace(/\/v1$/, "");
+  return `${root}/props`;
+}
+
+/** Pull the context window (n_ctx) out of a llama.cpp /props response. It lives
+ *  at default_generation_settings.n_ctx (the per-slot window — exactly what one
+ *  conversation can use); some builds also expose a top-level n_ctx. Returns
+ *  undefined when absent or not a positive number. */
+export function contextWindowFromProps(json: unknown): number | undefined {
+  const j = json as { default_generation_settings?: { n_ctx?: unknown }; n_ctx?: unknown } | null;
+  const n = Number(j?.default_generation_settings?.n_ctx ?? j?.n_ctx);
+  return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+
+export interface ProbeDeps {
+  fetchImpl?: typeof fetch;
+  timeoutMs?: number;
+  url?: string;
+}
+
+/** Ask a llama.cpp server for its live context window via /props. Returns
+ *  undefined on ANY failure (server down, no /props, non-JSON, timeout) so the
+ *  caller falls back to the declared window — never throws, never blocks beyond
+ *  timeoutMs. */
+export async function probeContextWindow(baseUrl: string, deps: ProbeDeps = {}): Promise<number | undefined> {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const url = deps.url ?? propsUrlFor(baseUrl);
+  const timeoutMs = deps.timeoutMs ?? 1500;
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(url, { signal: ctrl.signal });
+    if (!res.ok) return undefined;
+    return contextWindowFromProps(await res.json());
+  } catch {
+    return undefined;
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/.pi/extensions/llama-cpp-provider/index.ts

@@ -1,7 +1,7 @@
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { loadProviders } from "./config.ts";
+import { loadProviders, probeContextWindow } from "./config.ts";
 
 // Data-driven provider registration. Reads:
 //   1. <pkgRoot>/models.json                       (shipped default)
@@ -16,7 +16,7 @@ import { loadProviders } from "./config.ts";
 const here = dirname(fileURLToPath(import.meta.url));
 const pkgRoot = resolve(here, "..", "..", "..");
 
-export default function (pi: ExtensionAPI) {
+export default async function (pi: ExtensionAPI) {
   const result = loadProviders(pkgRoot);
 
   for (const src of result.sources) {
@@ -33,12 +33,32 @@ export default function (pi: ExtensionAPI) {
     return;
   }
 
+  // Opt-out for offline / CI / no-server launches that don't want a startup probe.
+  const probeDisabled = process.env.LITTLE_CODER_NO_CTX_PROBE === "1";
+
   for (const [name, entry] of Object.entries(result.providers)) {
+    let models = entry.models;
+
+    // Auto-detect the server's live context window so the model registers with
+    // the real n_ctx (e.g. a `-c 131072` server) instead of models.json's
+    // declared default — the TUI readout, read-guard, and context budget all
+    // follow the registered window. llama.cpp-only (the /props endpoint); any
+    // failure silently keeps the declared window, so this never breaks startup.
+    if (!probeDisabled && name === "llamacpp" && entry.models.length > 0) {
+      const probed = await probeContextWindow(entry.baseUrl, {
+        url: process.env.LITTLE_CODER_LLAMACPP_PROPS_URL || undefined,
+        timeoutMs: Number(process.env.LITTLE_CODER_CTX_PROBE_TIMEOUT_MS) || undefined,
+      });
+      if (probed) {
+        models = entry.models.map((m) => ({ ...m, contextWindow: probed }));
+      }
+    }
+
     pi.registerProvider(name, {
       baseUrl: entry.baseUrl,
       apiKey: entry.apiKey,
       api: entry.api,
-      models: entry.models,
+      models,
     });
   }
 }

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 All notable changes to little-coder are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and little-coder's public interface (CLI, providers, tools, skills) follows semver starting at `v0.0.1` post-rename.
 
+## [v1.8.1] — 2026-05-23
+
+### Fixed
+- **`glob` no longer exhausts memory on a recursive search from a huge root.** The tool capped *matches* at 500 but never bounded the *walk*: run from a home directory (or any tree with macOS `Library`, caches, or `node_modules`), `fs.glob` recursively descended everything and its internal traversal state grew until the Node **process** ran out of heap — a host-memory crash (`Ineffective mark-compacts near heap limit`), entirely distinct from the model's *context window* (the read-guard / window machinery operates on tool *results* in tokens; this died mid-walk, before any result existed). The walk is now bounded two ways: heavy/irrelevant directories (`node_modules`, `.git`, `dist`, `.cache`, `Library`, `venv`, `target`, …) are **pruned** — never descended — and a hard scan budget (200 000 entries) halts the walk through the one hook `fs.glob` calls per entry (`exclude`), since it exposes no signal/abort. When results are cut short the output says so, so the model narrows its search. New unit-tested `globFiles` / `renderGlobOutcome` helpers (`.pi/extensions/extra-tools/glob.ts`), verified to prune `node_modules` (0 descent) and to halt at the scan budget.
+
+### Notes for upgraders
+- For a focused search, pass a `path` (a project subdirectory) instead of globbing from a home directory. Hidden directories continue to be skipped by `fs.glob` as before.
+
+---
+
+## [v1.8.0] — 2026-05-23
+
+little-coder now **auto-detects the llama.cpp server's live context window** at startup and registers the model with it, so a `llama-server -c 131072` shows 128k instead of the declared default — no config edit. This completes [v1.7.0](#v170--2026-05-23): the budget already *followed* the registered window; now the registered window itself comes from the running server.
+
+### Added
+- **Live context-window detection for llama.cpp.** On startup `llama-cpp-provider` GETs the server's `/props` endpoint, reads its actual `n_ctx`, and registers the model with that window in place of the static `contextWindow` in `models.json`. The TUI context readout, read-guard's overflow trim, and the skill/knowledge budgets all then track the server's real window — bump `llama-server -c` and little-coder follows, no `models.json` or settings edit. The `/props` URL is derived from the provider baseUrl by stripping `/v1` (llama-server serves it at the root); the value is read from `default_generation_settings.n_ctx`. New tested helpers `propsUrlFor` / `contextWindowFromProps` / `probeContextWindow`, validated end-to-end against a live `-c 131072` server (→ 131072).
+  - **Best-effort and safe:** 1.5 s timeout, `llamacpp` provider only, and ANY failure (server down, no `/props`, non-JSON, timeout) silently falls back to the declared window — startup is never blocked or broken.
+  - **Env knobs:** `LITTLE_CODER_NO_CTX_PROBE=1` disables the probe (offline / CI); `LITTLE_CODER_LLAMACPP_PROPS_URL` overrides the `/props` URL for non-standard setups; `LITTLE_CODER_CTX_PROBE_TIMEOUT_MS` tunes the timeout.
+
+### Notes for upgraders
+- This adds one best-effort HTTP GET to the llama.cpp `/props` endpoint at launch (only for the `llamacpp` provider). If your server/proxy doesn't expose `/props`, behaviour is unchanged — the declared `models.json` `contextWindow` (default 32768) is used. Set `LITTLE_CODER_NO_CTX_PROBE=1` to skip the probe entirely.
+- No CLI-flag or public-API changes.
+
+---
+
 ## [v1.7.0] — 2026-05-23
 
 little-coder's context budget now follows the model's **live registered context window** instead of a hardcoded 32 768. Whatever window your provider declares for the active model (`contextWindow` in `models.json`, user-overridable) is what the whole harness budgets against — bump the model once and the TUI's context readout, read-guard's overflow trim, and the skill/knowledge-injection budgets all move together. This closes the common report: *"I bumped llama.cpp to 128k but little-coder still says 33k."*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "little-coder",
-  "version": "1.7.0",
+  "version": "1.8.1",
   "description": "A pi-based coding agent optimized for small local language models. Reproduces the whitepaper's scaffold-model-fit adaptations as pi extensions.",
   "homepage": "https://github.com/itayinbarr/little-coder",
   "repository": {