savemytokens 0.2.0

package/dist/runtime/statusline.mjs

@@ -0,0 +1,243 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import {
+  windowBounds,
+  loadConfig,
+  loadMeter,
+  loadQuota,
+  loadTheme,
+  renderHud,
+  sampleFiles,
+  saveQuota,
+  schedule,
+  upsertClaimant,
+  viewFor,
+} from "./kernel.mjs";
+
+const ADAPTER = "claude-code";
+const METER_THROTTLE_MS = 10 * 1000;
+const LIVENESS_THROTTLE_MS = 15 * 1000;
+const HISTORY_LIMIT = 96;
+const STALE_READING_MS = 10 * 60 * 1000;
+const MAX_SUBAGENT_DEPTH = 4;
+const WRAP_TIMEOUT_MS = 2000;
+
+function readInput() {
+  try {
+    const raw = fs.readFileSync(0, "utf8");
+    return raw ? { payload: JSON.parse(raw), raw } : null;
+  } catch {
+    return null;
+  }
+}
+
+function nested(dir, depth, out) {
+  if (depth > MAX_SUBAGENT_DEPTH) return;
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) nested(full, depth + 1, out);
+    else if (entry.name.endsWith(".jsonl")) out.push(full);
+  }
+}
+
+function transcriptFiles(payload) {
+  const transcript = payload.transcript_path;
+  if (typeof transcript !== "string" || !transcript) return [];
+  const files = [transcript];
+  nested(path.join(path.dirname(transcript), String(payload.session_id ?? "")), 1, files);
+  return files;
+}
+
+function normalizeWindows(rateLimits) {
+  const windows = {};
+  for (const key of ["five_hour", "seven_day", "spend_limit"]) {
+    const window = rateLimits?.[key];
+    if (!window || typeof window.used_percentage !== "number" || !Number.isFinite(window.used_percentage)) continue;
+    windows[key] = {
+      usedPercent: Math.max(0, Math.min(100, window.used_percentage)),
+      resetsAt: window.resets_at,
+    };
+  }
+  return windows;
+}
+
+const WINDOW_SPAN_MS = { five_hour: 5 * 3600_000, seven_day: 7 * 24 * 3600_000, spend_limit: 31 * 24 * 3600_000 };
+const SLACK_MS = 6 * 3600_000;
+
+function plausibleReset(key, resetsAt, now) {
+  if (typeof resetsAt !== "number" || !Number.isFinite(resetsAt) || resetsAt <= 0) return null;
+  const ms = resetsAt * 1000;
+  if (ms <= now) return null;
+  if (ms - now > (WINDOW_SPAN_MS[key] ?? WINDOW_SPAN_MS.seven_day) + SLACK_MS) return null;
+  return resetsAt;
+}
+
+function mergeWindows(stored, incoming, now) {
+  const merged = {};
+  for (const [key, window] of Object.entries(stored ?? {})) {
+    if (typeof window?.usedPercent !== "number") continue;
+    if (window.resetsAt !== undefined && plausibleReset(key, window.resetsAt, now) === null) continue;
+    merged[key] = window;
+  }
+  for (const [key, window] of Object.entries(incoming)) {
+    if (window.resetsAt !== undefined && plausibleReset(key, window.resetsAt, now) === null) continue;
+    const previous = merged[key];
+    if (!previous) {
+      merged[key] = { ...window, at: now };
+      continue;
+    }
+    const older = (window.resetsAt ?? 0) < (previous.resetsAt ?? 0);
+    if (older) continue;
+    const sameWindow = (window.resetsAt ?? 0) === (previous.resetsAt ?? 0);
+    merged[key] = {
+      ...window,
+      usedPercent: sameWindow ? Math.max(previous.usedPercent, window.usedPercent) : window.usedPercent,
+      at: now,
+    };
+  }
+  return merged;
+}
+
+function buildReading(payload, now) {
+  const incoming = normalizeWindows(payload.rate_limits);
+  const stored = loadQuota(ADAPTER);
+  const windows = mergeWindows(stored?.windows, incoming, now);
+  if (Object.keys(windows).length === 0) return null;
+  if (Object.keys(incoming).length === 0 && stored) return { ...stored, windows };
+  return {
+    at: now,
+    source: "statusline",
+    sessionId: String(payload.session_id ?? ""),
+    windows,
+    history: Array.isArray(stored?.history) ? stored.history : [],
+  };
+}
+
+function persistReading(reading, metered, turnAt) {
+  const previous = loadQuota(ADAPTER);
+  const history = Array.isArray(previous?.history) ? previous.history : [];
+  const last = history[history.length - 1];
+  const point = {
+    at: reading.at,
+    metered,
+    turnAt,
+    five_hour: reading.windows.five_hour?.usedPercent ?? null,
+    seven_day: reading.windows.seven_day?.usedPercent ?? null,
+  };
+  const changed =
+    !last ||
+    last.five_hour !== point.five_hour ||
+    last.seven_day !== point.seven_day ||
+    last.turnAt !== point.turnAt ||
+    reading.at - last.at > 10 * 60 * 1000;
+  saveQuota(ADAPTER, {
+    ...reading,
+    meteredTokens: metered,
+    history: changed ? [...history, point].slice(-HISTORY_LIMIT) : history,
+  });
+}
+
+function meterSession(payload, now) {
+  const id = String(payload.session_id ?? "");
+  if (!id) return;
+  const record = loadMeter(ADAPTER, id);
+  if (now - (record.meteredAt ?? 0) < METER_THROTTLE_MS) return;
+  const files = transcriptFiles(payload);
+  if (files.length === 0) return;
+  sampleFiles(ADAPTER, id, files, now);
+}
+
+function keepAlive(payload, now) {
+  const id = String(payload.session_id ?? "");
+  if (!id) return;
+  const project = payload.cwd || payload.workspace?.current_dir || "";
+  const label = project ? path.basename(project) : String(payload.session_name || "session");
+  upsertClaimant(ADAPTER, id, { project, label, heartbeat: now });
+}
+
+function wrappedOutput(config, raw) {
+  const command = config.wrappedStatusLine;
+  if (!command) return "";
+  try {
+    return String(
+      execSync(command, { input: raw, encoding: "utf8", timeout: WRAP_TIMEOUT_MS, stdio: ["pipe", "pipe", "ignore"] }),
+    ).trim();
+  } catch {
+    return "";
+  }
+}
+
+function run() {
+  const input = readInput();
+  if (!input) return;
+  const { payload, raw } = input;
+  const now = Date.now();
+  const config = loadConfig();
+
+  keepAlive(payload, now);
+  meterSession(payload, now);
+
+  const reading = buildReading(payload, now);
+  const fresh = Object.keys(normalizeWindows(payload.rate_limits)).length > 0;
+  const plan = schedule(ADAPTER, now, "five_hour", reading);
+  if (reading && fresh) {
+    let turnAt = 0;
+    for (const claimant of plan.claimants) turnAt = Math.max(turnAt, loadMeter(ADAPTER, claimant.claimant.id).lastAt ?? 0);
+    persistReading(reading, plan.totalWeighted, turnAt);
+  }
+
+  const view = viewFor(plan, String(payload.session_id ?? ""));
+  const theme = loadTheme(config.theme.hud);
+  const quota = {};
+  for (const key of ["five_hour", "seven_day", "spend_limit"]) {
+    const window = plan.quota?.windows?.[key];
+    if (window && (window.resetsAt === undefined || plausibleReset(key, window.resetsAt, now) !== null)) quota[key] = window;
+  }
+
+  const bounds = windowBounds(plan.quota, "five_hour", now);
+  const history = (plan.quota?.history ?? [])
+    .filter((point) => typeof point.five_hour === "number" && point.at >= bounds.from)
+    .map((point) => point.five_hour);
+  const rate = (() => {
+    const points = (plan.quota?.history ?? []).filter((point) => typeof point.five_hour === "number" && point.at >= now - 45 * 60 * 1000);
+    const first = points[0];
+    const last = points[points.length - 1];
+    if (!first || !last || last.at <= first.at) return null;
+    return ((last.five_hour - first.five_hour) / (last.at - first.at)) * 3600000;
+  })();
+
+  const line = renderHud(
+    config.hud?.segments ?? config.layout.hud,
+    {
+      label: view?.claimant.label || (payload.cwd ? path.basename(payload.cwd) : "session"),
+      target: view?.allocation.target ?? 1,
+      observed: view?.observed ?? 0,
+      used: view?.attributedPercent ?? null,
+      pressure: view?.pressure.value ?? 0,
+      priority: view?.claimant.priority ?? "normal",
+      quota,
+      history,
+      rate,
+      from: bounds.from,
+      to: bounds.to,
+      stale: !fresh && Object.keys(quota).length > 0 && now - (plan.quota?.at ?? 0) > STALE_READING_MS,
+      now,
+    },
+    theme,
+  );
+
+  const prefix = wrappedOutput(config, raw);
+  process.stdout.write(prefix ? `${prefix}  ${line}\n` : `${line}\n`);
+}
+
+try {
+  run();
+} catch {}
+process.exit(0);

package/dist/scheduler/keys.js

@@ -0,0 +1,112 @@
+const ESC = "\u001b";
+const FINAL = /[@-~]/;
+export function splitKeys(chunk) {
+    const keys = [];
+    let index = 0;
+    while (index < chunk.length) {
+        const char = chunk[index] ?? "";
+        if (char !== ESC) {
+            keys.push(char);
+            index++;
+            continue;
+        }
+        const next = chunk[index + 1];
+        if (next !== "[" && next !== "O") {
+            keys.push(ESC);
+            index++;
+            continue;
+        }
+        let end = index + 2;
+        while (end < chunk.length && !FINAL.test(chunk[end] ?? ""))
+            end++;
+        keys.push(chunk.slice(index, end + 1));
+        index = end + 1;
+    }
+    return keys;
+}
+export function actionFor(key, mode, step) {
+    if (key === "\u0003")
+        return { kind: "quit" };
+    if (mode === "prefs") {
+        if (key === "\r" || key === "\n")
+            return { kind: "save" };
+        if (key === ESC || key === "q")
+            return { kind: "skip" };
+        if (key === `${ESC}[A` || key === "k")
+            return { kind: "up" };
+        if (key === `${ESC}[B` || key === "j")
+            return { kind: "down" };
+        if (key === `${ESC}[C` || key === "l")
+            return { kind: "share", delta: step };
+        if (key === `${ESC}[D` || key === "h")
+            return { kind: "share", delta: -step };
+        if (key === " ")
+            return { kind: "toggleCurrent" };
+        if (key === "e")
+            return { kind: "edit" };
+        if (key === "s")
+            return { kind: "save" };
+        const index = Number(key) - 1;
+        if (Number.isInteger(index) && index >= 0 && index <= 8)
+            return { kind: "toggle", index };
+        return { kind: "none" };
+    }
+    switch (key) {
+        case "q":
+            return { kind: "quit" };
+        case ESC:
+            return { kind: "back" };
+        case `${ESC}[A`:
+        case "k":
+            return { kind: "up" };
+        case `${ESC}[B`:
+        case "j":
+            return { kind: "down" };
+        case `${ESC}[C`:
+        case "l":
+            return { kind: "share", delta: step };
+        case `${ESC}[D`:
+        case "h":
+            return { kind: "share", delta: -step };
+        case "p":
+            return { kind: "priority" };
+        case "e":
+            return { kind: "equalize" };
+        case "u":
+            return { kind: "unpin" };
+        case "d":
+            return { kind: "state", state: "done" };
+        case "b":
+            return { kind: "state", state: "blocked" };
+        case "a":
+            return { kind: "add" };
+        case "n":
+            return { kind: "state", state: "needs-more" };
+        case "r":
+            return { kind: "refresh" };
+        case "s":
+        case "P":
+        case ",":
+            return { kind: "preferences" };
+        case "?":
+            return { kind: "help" };
+        case "f":
+            return { kind: "pin" };
+        case " ":
+            return { kind: "toggleMember" };
+        case "x":
+            return { kind: "park" };
+        case "m":
+            return { kind: "expand" };
+        case "\r":
+        case "\n":
+            return { kind: "resume" };
+        default:
+            return { kind: "none" };
+    }
+}
+export function keyActions(chunk, mode, step) {
+    return splitKeys(chunk)
+        .map((key) => actionFor(key, mode, step))
+        .filter((action) => action.kind !== "none");
+}

package/dist/scheduler/plan.js

@@ -0,0 +1,287 @@
+import fs from "node:fs";
+import path from "node:path";
+import { withMoved, withToggled } from "../report/settings.js";
+import { claudeCodeProvider } from "../adapters/claude-code/provider.js";
+import { codexProvider } from "../adapters/codex/provider.js";
+import { DEFAULT_CONFIG, HOOKS_DIR, FIVE_HOUR_MS, WINDOW_MS, clearDeferred, deferredProjects, loadClaimants, loadConfig, loadProjects, presetMatching, presetSegments, upsertProject, loadQuota, policyNames, saveConfig, schedule, upsertClaimant, windowBounds, } from "../runtime/kernel.mjs";
+export const providers = [claudeCodeProvider, codexProvider];
+export function providerFor(id) {
+    return providers.find((provider) => provider.id === id) ?? claudeCodeProvider;
+}
+export function detectedProviders() {
+    return providers.filter((provider) => provider.detect());
+}
+const QUIET_MS = 5 * 60 * 1000;
+function unattributedPercent(plan) {
+    const history = plan.quota?.history;
+    if (!Array.isArray(history) || history.length < 2)
+        return null;
+    let drift = 0;
+    let anchor = null;
+    for (const point of history) {
+        if (point.at < plan.bounds.from)
+            continue;
+        if (typeof point.five_hour !== "number" || typeof point.metered !== "number")
+            continue;
+        const here = { at: point.at, metered: point.metered, five_hour: point.five_hour };
+        if (!anchor) {
+            anchor = here;
+            continue;
+        }
+        if (here.metered > anchor.metered) {
+            anchor = here;
+            continue;
+        }
+        if (here.at - anchor.at < QUIET_MS)
+            continue;
+        const moved = here.five_hour - anchor.five_hour;
+        if (moved > 0)
+            drift += moved;
+        anchor = here;
+    }
+    return drift > 0 ? drift : null;
+}
+export function buildPlan(now = Date.now(), withSweep = true, window = "five_hour", adapter = "claude-code") {
+    const provider = providerFor(adapter);
+    if (withSweep) {
+        const bounds = windowBounds(loadQuota(provider.id), window, now);
+        const span = WINDOW_MS[window] ?? FIVE_HOUR_MS;
+        provider.sweep(Math.min(bounds.from, now - span), now);
+    }
+    const plan = schedule(provider.id, now, window, null, provider.dataDir ?? null);
+    const others = detectedProviders()
+        .filter((other) => other.id !== provider.id)
+        .map((other) => ({ id: other.id, label: other.label, resources: other.resources(now) }));
+    return {
+        provider,
+        schedule: plan,
+        resources: provider.resources(now),
+        config: loadConfig(),
+        enforcement: provider.enforcer.supports,
+        unattributed: unattributedPercent(plan),
+        deferred: deferredProjects(provider.id, now),
+        others,
+        installed: fs.existsSync(path.join(HOOKS_DIR, "statusline.mjs")),
+    };
+}
+const CANDIDATE_LIMIT = 12;
+export function inPlan(view) {
+    if (view.bucket === "active")
+        return true;
+    if (view.settings.kept === true)
+        return true;
+    if (view.settings.kept === false)
+        return false;
+    return view.settings.pinned || (view.settings.share ?? 0) > 0;
+}
+function byInterest(a, b) {
+    const live = Number(b.bucket === "active") - Number(a.bucket === "active");
+    if (live !== 0)
+        return live;
+    return (Number(b.settings.pinned) - Number(a.settings.pinned) ||
+        (b.allocation.target || b.settings.share || 0) - (a.allocation.target || a.settings.share || 0) ||
+        b.lastSeen - a.lastSeen);
+}
+export function workingSet(plan, full = false) {
+    const members = plan.projects.filter(inPlan).sort(byInterest);
+    const rest = plan.projects.filter((view) => !inPlan(view));
+    const open = rest.filter((view) => !view.settings.parked).sort(byInterest);
+    const buried = rest.filter((view) => view.settings.parked).sort(byInterest);
+    const candidates = full ? [...open, ...buried] : open.slice(0, CANDIDATE_LIMIT);
+    return { members, candidates, hidden: rest.length - candidates.length };
+}
+export function visibleRows(plan, full = false) {
+    const set = workingSet(plan, full);
+    return [...set.members, ...set.candidates];
+}
+export function joinPlan(project, adapter = "claude-code") {
+    upsertProject(adapter, project, { kept: true });
+}
+export function leavePlan(project, adapter = "claude-code") {
+    upsertProject(adapter, project, { kept: false });
+}
+export function demote(view, adapter = "claude-code") {
+    if (inPlan(view))
+        upsertProject(adapter, view.project, { kept: false });
+    else
+        upsertProject(adapter, view.project, { parked: true, kept: false });
+}
+export function promote(view, adapter = "claude-code") {
+    if (view.settings.parked)
+        upsertProject(adapter, view.project, { parked: false });
+    else
+        upsertProject(adapter, view.project, { kept: true, parked: false });
+}
+export function activeViews(plan) {
+    return workingSet(plan).members.filter((view) => view.bucket === "active");
+}
+export function selectionIndex(ids, selectedId, previousIndex) {
+    if (ids.length === 0)
+        return 0;
+    if (selectedId) {
+        const found = ids.indexOf(selectedId);
+        if (found !== -1)
+            return found;
+    }
+    return Math.max(0, Math.min(previousIndex, ids.length - 1));
+}
+export function cleanShare(share) {
+    if (share === null || !Number.isFinite(share))
+        return null;
+    const clamped = Math.max(0, Math.min(1, share));
+    const rounded = Math.round(clamped * 200) / 200;
+    return rounded < 0.005 ? 0 : rounded;
+}
+export function nextShare(view, delta) {
+    const from = view.settings.share ?? view.allocation.target;
+    return Math.max(0, Math.min(1, from + delta));
+}
+export function setShare(project, share, adapter = "claude-code") {
+    upsertProject(adapter, project, { share: cleanShare(share) });
+}
+export function setPriority(project, priority, adapter = "claude-code") {
+    upsertProject(adapter, project, { priority });
+}
+export function setState(project, state, adapter = "claude-code") {
+    for (const claimant of loadClaimants(adapter)) {
+        if ((claimant.project || claimant.label) !== project)
+            continue;
+        upsertClaimant(adapter, claimant.id, { state, endedAt: state === "done" ? Date.now() : null });
+    }
+}
+export function equalize(adapter = "claude-code") {
+    for (const project of loadProjects(adapter)) {
+        if (project.share === null)
+            continue;
+        upsertProject(adapter, project.project, { share: null });
+    }
+}
+export function cyclePriority(current) {
+    if (current === "high")
+        return "normal";
+    if (current === "normal")
+        return "low";
+    return "high";
+}
+export function savePreference(project, kinds) {
+    const config = loadConfig();
+    config.preserveFor[project || "default"] = kinds;
+    config.preferencesSetAt = Date.now();
+    saveConfig(config);
+}
+export function resetPreferences() {
+    const config = loadConfig();
+    const fresh = JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+    saveConfig({
+        ...fresh,
+        version: config.version,
+        createdAt: config.createdAt,
+        preferencesSetAt: Date.now(),
+        offeredInstallAt: config.offeredInstallAt,
+        wrappedStatusLine: config.wrappedStatusLine,
+    });
+}
+export function toggleColumn(id) {
+    const config = loadConfig();
+    const columns = withToggled(config.columns, id);
+    config.columns = columns.length > 0 ? columns : [id];
+    saveConfig(config);
+}
+export function cyclePreset(delta, names) {
+    if (names.length === 0)
+        return;
+    const config = loadConfig();
+    const current = presetMatching(config.hud.segments);
+    const at = current ? names.indexOf(current) : -1;
+    const next = names[(at + delta + names.length * 2) % names.length] ?? names[0];
+    const segments = next ? presetSegments(next) : null;
+    if (segments) {
+        config.hud.segments = [...segments];
+        saveConfig(config);
+    }
+}
+export function toggleSegment(id) {
+    const config = loadConfig();
+    config.hud.segments = withToggled(config.hud.segments, id);
+    saveConfig(config);
+}
+export function moveSegment(id, delta) {
+    const config = loadConfig();
+    config.hud.segments = withMoved(config.hud.segments, id, delta);
+    saveConfig(config);
+}
+export function cycleTheme(surface, delta, names) {
+    if (names.length === 0)
+        return;
+    const config = loadConfig();
+    const at = names.indexOf(config.theme[surface]);
+    const next = names[(at + delta + names.length) % names.length] ?? names[0];
+    if (next)
+        config.theme[surface] = next;
+    saveConfig(config);
+}
+export function cyclePolicy(delta) {
+    const names = policyNames();
+    const config = loadConfig();
+    const at = names.indexOf(config.policy);
+    const next = names[(at + delta + names.length) % names.length] ?? names[0];
+    if (next)
+        config.policy = next;
+    saveConfig(config);
+}
+export function togglePreserve(kind) {
+    const config = loadConfig();
+    const current = config.preserveFor.default ?? [];
+    const next = current.includes(kind) ? current.filter((value) => value !== kind) : [...current, kind];
+    config.preserveFor.default = next;
+    config.preferencesSetAt = Date.now();
+    saveConfig(config);
+}
+export function saveCustomAdvice(project, text) {
+    const config = loadConfig();
+    const key = project || "default";
+    const value = text.trim();
+    if (value)
+        config.customAdvice[key] = value;
+    else
+        delete config.customAdvice[key];
+    saveConfig(config);
+}
+export function setPinned(project, pinned, adapter = "claude-code") {
+    upsertProject(adapter, project, { pinned });
+}
+export function setParked(project, parked, adapter = "claude-code") {
+    upsertProject(adapter, project, { parked });
+    if (parked)
+        setState(project, "done", adapter);
+}
+export function setPolicy(name, project) {
+    if (!policyNames().includes(name))
+        return false;
+    const config = loadConfig();
+    if (project)
+        config.policyFor[project] = name;
+    else
+        config.policy = name;
+    saveConfig(config);
+    return true;
+}
+export function forgetDeferred(project, adapter = "claude-code") {
+    clearDeferred(adapter, project);
+}
+export function resolveClaimant(plan, term) {
+    const needle = term.trim().toLowerCase();
+    if (!needle)
+        return null;
+    const pool = plan.projects;
+    const exact = pool.filter((view) => view.project === term || view.label.toLowerCase() === needle);
+    const partial = pool.filter((view) => view.label.toLowerCase().includes(needle) || view.project.toLowerCase().includes(needle));
+    const candidates = exact.length > 0 ? exact : partial;
+    if (candidates.length === 0)
+        return null;
+    const ranked = [...candidates].sort((a, b) => Number(b.bucket === "active") - Number(a.bucket === "active") || b.observed - a.observed);
+    const view = ranked[0];
+    if (!view)
+        return null;
+    return { view, matches: candidates.length };
+}

package/dist/storage/cache.js

@@ -0,0 +1,38 @@
+import fs from "node:fs";
+import path from "node:path";
+import { EVIDENCE_SCHEMA } from "../core/types.js";
+import { CACHE_DIR, readJson, writeJson } from "./paths.js";
+const RETENTION_MS = 120 * 24 * 60 * 60 * 1000;
+export class EvidenceCache {
+    file;
+    data;
+    dirty = false;
+    constructor(adapter) {
+        this.file = path.join(CACHE_DIR, `${adapter}.json`);
+        const loaded = readJson(this.file, { schema: EVIDENCE_SCHEMA, entries: {} });
+        this.data = loaded.schema === EVIDENCE_SCHEMA && loaded.entries ? loaded : { schema: EVIDENCE_SCHEMA, entries: {} };
+    }
+    get(file, size, mtimeMs) {
+        const hit = this.data.entries[file];
+        if (!hit)
+            return null;
+        if (hit.sourceSize !== size || Math.abs(hit.sourceMtimeMs - mtimeMs) > 1)
+            return null;
+        return hit;
+    }
+    set(evidence) {
+        this.data.entries[evidence.sourceFile] = evidence;
+        this.dirty = true;
+    }
+    flush() {
+        if (!this.dirty)
+            return;
+        const cutoff = Date.now() - RETENTION_MS;
+        for (const [file, evidence] of Object.entries(this.data.entries)) {
+            if (evidence.sourceMtimeMs < cutoff || !fs.existsSync(file))
+                delete this.data.entries[file];
+        }
+        writeJson(this.file, this.data);
+        this.dirty = false;
+    }
+}