open-walnut 0.3.0

package/dist/workers/git-compaction-worker.js

@@ -0,0 +1,898 @@
+// src/logging/logger.ts
+import fs2 from "fs";
+import fsp from "fs/promises";
+import path2 from "path";
+
+// src/constants.ts
+import path from "path";
+import fs from "fs";
+import os from "os";
+import { fileURLToPath } from "url";
+var WALNUT_HOME = resolveOpenWalnutHome();
+var IS_EPHEMERAL = process.argv.includes("--_ephemeral-child");
+var CLOUD_MODE = process.env.WALNUT_CLOUD_MODE === "1";
+function resolveOpenWalnutHome() {
+  const envHome = process.env.OPEN_WALNUT_HOME;
+  const productionHome = path.join(os.homedir(), ".open-walnut");
+  const isTestEnv = !!(process.env.VITEST || process.env.VITEST_WORKER_ID || process.env.NODE_ENV === "test");
+  if (isTestEnv) {
+    if (envHome && envHome !== productionHome && !envHome.startsWith(productionHome + path.sep)) {
+      assertNotProductionPath(envHome);
+      return envHome;
+    }
+    const testHome = path.join(os.tmpdir(), `open-walnut-test-${process.pid}`);
+    process.env.OPEN_WALNUT_HOME = testHome;
+    return testHome;
+  }
+  if (!envHome) return productionHome;
+  if (process.argv.includes("--_ephemeral-child")) return envHome;
+  if (isEphemeralTmpDir(envHome)) {
+    process.stderr.write(
+      `WARNING: OPEN_WALNUT_HOME=${envHome} looks like a leaked ephemeral temp dir.
+  Overriding to ${productionHome}. (Only --_ephemeral-child processes may use one.)
+`
+    );
+    process.env.OPEN_WALNUT_HOME = productionHome;
+    return productionHome;
+  }
+  return envHome;
+}
+function assertNotProductionPath(inputPath) {
+  const isTestEnv = !!(process.env.VITEST || process.env.VITEST_WORKER_ID || process.env.NODE_ENV === "test");
+  if (!isTestEnv) return;
+  const resolved = path.resolve(inputPath);
+  const prodHome = path.join(os.homedir(), ".open-walnut");
+  if (resolved === prodHome || resolved.startsWith(prodHome + path.sep)) {
+    throw new Error(
+      `SAFETY: Test process attempted to use production path: ${resolved}
+  This would destroy real user data in ~/.open-walnut/.
+  Set OPEN_WALNUT_HOME to a temp directory or let constants.ts auto-assign one.`
+    );
+  }
+}
+function isEphemeralTmpDir(inputPath) {
+  if (!/[\\/]open-walnut-[^\\/]+$/.test(inputPath)) return false;
+  const tmpDirs = /* @__PURE__ */ new Set();
+  tmpDirs.add(os.tmpdir());
+  try {
+    tmpDirs.add(fs.realpathSync(os.tmpdir()));
+  } catch {
+  }
+  try {
+    tmpDirs.add(fs.realpathSync("/tmp"));
+  } catch {
+  }
+  const parent = path.dirname(path.resolve(inputPath));
+  if (tmpDirs.has(parent)) return true;
+  try {
+    return tmpDirs.has(fs.realpathSync(parent));
+  } catch {
+    return false;
+  }
+}
+var TASKS_DIR = path.join(WALNUT_HOME, "tasks");
+var TASKS_FILE = path.join(TASKS_DIR, "tasks.json");
+var ARCHIVE_DIR = path.join(TASKS_DIR, "archive");
+var MEMORY_DIR = path.join(WALNUT_HOME, "memory");
+var SESSIONS_DIR = path.join(MEMORY_DIR, "sessions");
+var PROJECTS_DIR = path.join(MEMORY_DIR, "projects");
+var CONFIG_FILE = path.join(WALNUT_HOME, "config.yaml");
+var SYNC_DIR = path.join(WALNUT_HOME, "sync");
+var PLUGIN_STORES_DIR = path.join(WALNUT_HOME, "plugin-stores");
+var SESSIONS_FILE = path.join(WALNUT_HOME, "sessions.json");
+var CLAUDE_HOME = path.join(os.homedir(), ".claude");
+var HISTORY_CACHE_DIR = path.join(WALNUT_HOME, "cache", "history");
+var PROJECTION_CACHE_DIR = path.join(WALNUT_HOME, "cache", "projections");
+var TRANSCRIPT_CACHE_DIR = path.join(WALNUT_HOME, "cache", "transcripts");
+var TASK_QUEUE_DIR = path.join(WALNUT_HOME, "cache", "task-queue");
+var HOST_MODEL_CATALOG_FILE = path.join(WALNUT_HOME, "cache", "host-model-catalogs.json");
+var HOOK_LOG_FILE = path.join(WALNUT_HOME, "hook-errors.log");
+var DAILY_DIR = path.join(MEMORY_DIR, "daily");
+var MEMORY_FILE = path.join(MEMORY_DIR, "MEMORY.md");
+var USER_FILE = path.join(MEMORY_DIR, "USER.md");
+var LEGACY_MEMORY_FILE = path.join(WALNUT_HOME, "MEMORY.md");
+var PROJECTS_MEMORY_DIR = path.join(MEMORY_DIR, "projects");
+var CHAT_HISTORY_FILE = path.join(WALNUT_HOME, "chat-history.json");
+var CONVERSATIONS_DIR = path.join(WALNUT_HOME, "conversations");
+var GLOBAL_SKILLS_DIR = path.join(WALNUT_HOME, "skills");
+var SKILL_SETTINGS_FILE = path.join(WALNUT_HOME, "skill-settings.json");
+var CLAUDE_SKILLS_DIR = path.join(CLAUDE_HOME, "skills");
+var CLAUDE_SETTINGS_FILE = path.join(CLAUDE_HOME, "settings.json");
+var CLAUDE_PLUGINS_DIR = path.join(CLAUDE_HOME, "plugins");
+var CLAUDE_CREDENTIALS_FILE = path.join(CLAUDE_HOME, ".credentials.json");
+var CRON_FILE = path.join(WALNUT_HOME, "cron-jobs.json");
+var USAGE_DB_FILE = path.join(WALNUT_HOME, "usage.sqlite");
+var LOG_DIR = process.env.WALNUT_DAEMON_DIR || "/tmp/open-walnut";
+var SESSION_STREAMS_DIR = path.join(LOG_DIR, "streams");
+var DTACH_SOCKET_DIR = path.join(LOG_DIR, "term");
+var SESSION_QUEUE_FILE = path.join(WALNUT_HOME, "session-message-queue.json");
+var IMAGES_DIR = path.join(LOG_DIR, "images");
+var REMOTE_IMAGES_DIR = path.join(IMAGES_DIR, "remote");
+var PASTES_DIR = path.join(LOG_DIR, "pastes");
+var HEARTBEAT_FILE = path.join(WALNUT_HOME, "HEARTBEAT.md");
+var COMMANDS_DIR = path.join(WALNUT_HOME, "commands");
+var BUILTIN_COMMANDS_DIR = (() => {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 5; i++) {
+    const candidate = path.join(dir, "data", "slash-commands");
+    try {
+      if (fs.statSync(candidate).isDirectory()) return candidate;
+    } catch {
+    }
+    dir = path.dirname(dir);
+  }
+  return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "data", "slash-commands");
+})();
+var BUILTIN_SKILLS_DIR = (() => {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 5; i++) {
+    const candidate = path.join(dir, "data", "skills");
+    try {
+      if (fs.statSync(candidate).isDirectory()) return candidate;
+    } catch {
+    }
+    dir = path.dirname(dir);
+  }
+  return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "data", "skills");
+})();
+var FREQUENT_DIRS_FILE = path.join(WALNUT_HOME, "frequent-directories.json");
+var MENTION_DIRS_FILE = path.join(WALNUT_HOME, "mention-directories.json");
+var NOTES_DIR = path.join(WALNUT_HOME, "notes");
+var GLOBAL_NOTES_FILE = path.join(NOTES_DIR, "global-notes.md");
+var NOTES_AGENTS_FILE = path.join(NOTES_DIR, "AGENTS.md");
+var NOTES_CLAUDE_FILE = path.join(NOTES_DIR, "CLAUDE.md");
+var REPOSITORIES_DIR = path.join(WALNUT_HOME, "repositories");
+var REPOS_MEMORY_DIR = path.join(GLOBAL_SKILLS_DIR, "repos");
+var TOPICS_DIR = path.join(MEMORY_DIR, "topics");
+var COMPACTION_DIR = path.join(MEMORY_DIR, "compaction");
+var MEMORY_INDEX_FILE = path.join(MEMORY_DIR, "index.md");
+var WORKING_MEMORY_FILE = path.join(MEMORY_DIR, "working-memory.md");
+var TIMELINE_DIR = path.join(WALNUT_HOME, "timeline");
+var CONFIG_SHARE_DIR = path.join(WALNUT_HOME, "config", "share");
+var UI_PREFS_FILE = path.join(CONFIG_SHARE_DIR, "ui-prefs.json");
+var STT_VOCAB_FILE = path.join(CONFIG_SHARE_DIR, "stt-vocab.txt");
+var TMP_DIR = path.join(WALNUT_HOME, "tmp");
+var RECORDINGS_DIR = path.join(TMP_DIR, "recordings");
+var LOG_PREFIX = "open-walnut-";
+var DAEMON_BINARIES_DIR = (() => {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 5; i++) {
+    const candidate = path.join(dir, "dist", "daemon-binaries");
+    try {
+      if (fs.statSync(candidate).isDirectory()) return candidate;
+    } catch {
+    }
+    dir = path.dirname(dir);
+  }
+  return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "dist", "daemon-binaries");
+})();
+var WALNUT_INSTALL_DIR = (() => {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 6; i++) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
+      if (pkg.name === "open-walnut" && fs.statSync(path.join(dir, ".git")).isDirectory()) return dir;
+    } catch {
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+})();
+
+// src/logging/redact.ts
+var REDACTED = "[REDACTED]";
+var patterns = [
+  // PEM private key blocks (multiline)
+  {
+    re: /-----BEGIN\s[\w\s]*PRIVATE KEY-----[\s\S]*?-----END\s[\w\s]*PRIVATE KEY-----/g,
+    replacement: REDACTED
+  },
+  // Bearer tokens: Authorization: Bearer <token>
+  {
+    re: /(Bearer\s+)\S+/gi,
+    replacement: `$1${REDACTED}`
+  },
+  // OpenAI / Anthropic style keys: sk-... (at least 20 chars after prefix)
+  {
+    re: /\bsk-[A-Za-z0-9_-]{20,}\b/g,
+    replacement: REDACTED
+  },
+  // AWS access key IDs: AKIA...
+  {
+    re: /\bAKIA[A-Z0-9]{12,}\b/g,
+    replacement: REDACTED
+  },
+  // AWS secret access key in key=value form
+  {
+    re: /(aws_secret_access_key\s*[=:]\s*)\S+/gi,
+    replacement: `$1${REDACTED}`
+  },
+  // AWS session token in key=value form
+  {
+    re: /(aws_session_token\s*[=:]\s*)\S+/gi,
+    replacement: `$1${REDACTED}`
+  },
+  // Credentials in URL userinfo: https://user:secret@host/...
+  // Motivating shape: execSync embeds the whole command in error.message, so a
+  // failed `git remote add origin https://walnut:<device-token>@host/git/data`
+  // otherwise logs the cloud companion's long-lived credential verbatim.
+  {
+    re: /(https?:\/\/[^/\s:@]+:)[^@/\s]+@/gi,
+    replacement: `$1${REDACTED}@`
+  },
+  // Generic secrets: password=, secret=, token=, api_key=, apikey=
+  {
+    re: /((?:password|secret|token|api_key|apikey)\s*[=:]\s*)\S+/gi,
+    replacement: `$1${REDACTED}`
+  }
+];
+function redactSensitiveText(text) {
+  let result = text;
+  for (const { re, replacement } of patterns) {
+    result = result.replace(re, replacement);
+  }
+  return result;
+}
+
+// src/logging/logger.ts
+var dirEnsured = false;
+function ensureLogDir() {
+  if (dirEnsured) return;
+  try {
+    fs2.mkdirSync(LOG_DIR, { recursive: true });
+    dirEnsured = true;
+  } catch {
+  }
+}
+function todayFileName() {
+  const d = /* @__PURE__ */ new Date();
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return `${LOG_PREFIX}${yyyy}-${mm}-${dd}.log`;
+}
+function logFilePath() {
+  return path2.join(LOG_DIR, todayFileName());
+}
+function pruneOldLogs(maxAgeDays) {
+  let entries;
+  try {
+    entries = fs2.readdirSync(LOG_DIR);
+  } catch {
+    return;
+  }
+  const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
+  for (const name of entries) {
+    if (!name.startsWith(LOG_PREFIX) || !name.endsWith(".log")) continue;
+    const full = path2.join(LOG_DIR, name);
+    try {
+      const stat = fs2.statSync(full);
+      if (stat.mtimeMs < cutoff) {
+        fs2.unlinkSync(full);
+      }
+    } catch {
+    }
+  }
+}
+var FLUSH_INTERVAL_MS = 2e3;
+var buffer = [];
+var flushTimer = null;
+var flushing = false;
+function startFlushTimer() {
+  if (flushTimer) return;
+  flushTimer = setInterval(() => {
+    void flushLogBuffer();
+  }, FLUSH_INTERVAL_MS);
+  if (flushTimer && typeof flushTimer === "object" && "unref" in flushTimer) {
+    flushTimer.unref();
+  }
+}
+async function flushLogBuffer() {
+  if (flushing || buffer.length === 0) return;
+  flushing = true;
+  const batch = buffer;
+  buffer = [];
+  try {
+    ensureLogDir();
+    await fsp.appendFile(logFilePath(), batch.join(""), "utf-8");
+  } catch {
+  } finally {
+    flushing = false;
+  }
+}
+function flushLogBufferSync() {
+  if (buffer.length === 0) return;
+  const batch = buffer;
+  buffer = [];
+  try {
+    ensureLogDir();
+    fs2.appendFileSync(logFilePath(), batch.join(""), "utf-8");
+  } catch {
+  }
+}
+process.on("beforeExit", flushLogBufferSync);
+process.on("exit", flushLogBufferSync);
+function initFileLogger() {
+  fs2.mkdirSync(LOG_DIR, { recursive: true });
+  dirEnsured = true;
+  pruneOldLogs(3);
+}
+function writeLogEntry(entry) {
+  const line = redactSensitiveText(JSON.stringify(entry)) + "\n";
+  buffer.push(line);
+  startFlushTimer();
+}
+
+// src/logging/subsystem.ts
+import chalk from "chalk";
+
+// src/logging/levels.ts
+var LOG_LEVEL_ORDER = {
+  trace: 0,
+  debug: 1,
+  info: 2,
+  warn: 3,
+  error: 4,
+  fatal: 5
+};
+var DEFAULT_LEVEL = "info";
+function resolveConfiguredLevel() {
+  const raw = process.env.WALNUT_LOG_LEVEL?.toLowerCase().trim();
+  if (raw && raw in LOG_LEVEL_ORDER) return raw;
+  return DEFAULT_LEVEL;
+}
+var CONFIGURED_LOG_LEVEL = resolveConfiguredLevel();
+function shouldLog(messageLevel, configuredLevel = CONFIGURED_LOG_LEVEL) {
+  return LOG_LEVEL_ORDER[messageLevel] >= LOG_LEVEL_ORDER[configuredLevel];
+}
+
+// src/logging/subsystem.ts
+var levelColor = {
+  trace: chalk.gray,
+  debug: chalk.cyan,
+  info: chalk.green,
+  warn: chalk.yellow,
+  error: chalk.red,
+  fatal: chalk.bgRed.white
+};
+var levelLabel = {
+  trace: "TRC",
+  debug: "DBG",
+  info: "INF",
+  warn: "WRN",
+  error: "ERR",
+  fatal: "FTL"
+};
+function timeStamp(d) {
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  const ss = String(d.getSeconds()).padStart(2, "0");
+  return `${hh}:${mm}:${ss}`;
+}
+function formatMeta(meta) {
+  if (!meta || Object.keys(meta).length === 0) return "";
+  return " " + chalk.dim(JSON.stringify(meta));
+}
+var ERROR_SINK_KEY = /* @__PURE__ */ Symbol.for("open-walnut.errorNotificationSink");
+var inErrorSink = false;
+function forwardToErrorSink(subsystem, message, meta) {
+  const sink = globalThis[ERROR_SINK_KEY];
+  if (!sink || inErrorSink) return;
+  if (subsystem.startsWith("notif")) return;
+  inErrorSink = true;
+  try {
+    sink({ subsystem, message, meta });
+  } catch {
+  } finally {
+    inErrorSink = false;
+  }
+}
+function emit(level, subsystem, message, meta) {
+  if (!shouldLog(level)) return;
+  const now = /* @__PURE__ */ new Date();
+  writeLogEntry({
+    time: now.toISOString(),
+    level,
+    subsystem,
+    message,
+    ...meta && Object.keys(meta).length > 0 ? meta : {}
+  });
+  if (level === "error" || level === "fatal") {
+    forwardToErrorSink(subsystem, message, meta);
+  }
+  try {
+    const colorFn = levelColor[level];
+    const tag = chalk.bold(`[${subsystem}]`);
+    const lbl = colorFn(levelLabel[level]);
+    const ts = chalk.dim(timeStamp(now));
+    const metaStr = formatMeta(meta);
+    const line = redactSensitiveText(`${ts} ${lbl} ${tag} ${message}${metaStr}
+`);
+    process.stderr.write(line);
+  } catch {
+  }
+}
+function createSubsystemLogger(subsystem) {
+  const logger = {
+    trace: (msg, meta) => emit("trace", subsystem, msg, meta),
+    debug: (msg, meta) => emit("debug", subsystem, msg, meta),
+    info: (msg, meta) => emit("info", subsystem, msg, meta),
+    warn: (msg, meta) => emit("warn", subsystem, msg, meta),
+    error: (msg, meta) => emit("error", subsystem, msg, meta),
+    fatal: (msg, meta) => emit("fatal", subsystem, msg, meta),
+    child(subName) {
+      return createSubsystemLogger(`${subsystem}/${subName}`);
+    }
+  };
+  return logger;
+}
+
+// src/logging/index.ts
+var log = {
+  bus: createSubsystemLogger("bus"),
+  agent: createSubsystemLogger("agent"),
+  session: createSubsystemLogger("session"),
+  subagent: createSubsystemLogger("subagent"),
+  web: createSubsystemLogger("web"),
+  ws: createSubsystemLogger("ws"),
+  hook: createSubsystemLogger("hook"),
+  task: createSubsystemLogger("task"),
+  memory: createSubsystemLogger("memory"),
+  cron: createSubsystemLogger("cron"),
+  notif: createSubsystemLogger("notif"),
+  usage: createSubsystemLogger("usage"),
+  heartbeat: createSubsystemLogger("heartbeat"),
+  git: createSubsystemLogger("git"),
+  browser: createSubsystemLogger("browser"),
+  audio: createSubsystemLogger("audio"),
+  stt: createSubsystemLogger("stt"),
+  obs: createSubsystemLogger("obs"),
+  calendar: createSubsystemLogger("calendar")
+};
+var initialized = false;
+function initLogging() {
+  if (initialized) return;
+  initialized = true;
+  initFileLogger();
+}
+
+// src/integrations/git-compaction.ts
+import fs4 from "fs";
+import path4 from "path";
+
+// src/integrations/git-sync.ts
+import { execSync, exec, spawn } from "child_process";
+import { promisify } from "util";
+import fs3 from "fs";
+import os2 from "os";
+import path3 from "path";
+
+// src/core/event-bus.ts
+import { randomBytes } from "crypto";
+var EVENT_HISTORY_SIZE = 200;
+var eventHistory = [];
+var KEY_BUS_EVENTS = /* @__PURE__ */ new Set([
+  "session:start",
+  "session:send",
+  "session:started",
+  "session:ended",
+  "session:deleted",
+  "session:content-updated",
+  "session:result",
+  "session:error",
+  "session:status-changed",
+  "subagent:start",
+  "subagent:result",
+  "subagent:error",
+  "task:created",
+  "task:updated",
+  "task:completed",
+  "task:deleted",
+  "task:unblocked"
+]);
+var EventBus = class {
+  subscribers = /* @__PURE__ */ new Map();
+  /**
+   * Register a named subscriber.
+   * Events are delivered only when the subscriber's name is in the event's destinations
+   * (or destinations includes "*"), unless `global: true` is set — then the subscriber
+   * receives ALL events regardless of destinations.
+   */
+  subscribe(name, handler, filter) {
+    if (filter && typeof filter === "object" && ("global" in filter || "interest" in filter || "filter" in filter)) {
+      this.subscribers.set(name, { name, handler, filter: filter.filter, global: filter.global, interest: filter.interest });
+    } else {
+      this.subscribers.set(name, { name, handler, filter });
+    }
+  }
+  /**
+   * Remove a subscriber by name.
+   */
+  unsubscribe(name) {
+    this.subscribers.delete(name);
+  }
+  emit(name, data, destinations, options) {
+    const event = {
+      name,
+      data,
+      destinations,
+      urgency: options?.urgency ?? "normal",
+      timestamp: Date.now(),
+      source: options?.source ?? "unknown",
+      traceId: randomBytes(4).toString("hex"),
+      ...options?.reemit ? { reemit: true } : {}
+    };
+    eventHistory.push(event);
+    if (eventHistory.length > EVENT_HISTORY_SIZE) {
+      eventHistory.shift();
+    }
+    log.bus.debug(`emit ${name}`, { traceId: event.traceId, destinations, source: options?.source });
+    if (KEY_BUS_EVENTS.has(name)) {
+      log.bus.info(`emit ${name}`, { traceId: event.traceId, destinations, source: options?.source });
+    }
+    for (const [, subscriber] of this.subscribers) {
+      if (subscriber.global && event.reemit) continue;
+      if (!subscriber.global && !destinations.includes("*") && !destinations.includes(subscriber.name)) {
+        continue;
+      }
+      if (subscriber.global && subscriber.interest && !subscriber.interest.some((p) => name.startsWith(p))) {
+        continue;
+      }
+      if (subscriber.filter && !subscriber.filter(event)) {
+        continue;
+      }
+      try {
+        log.bus.debug("event delivered", { name, subscriber: subscriber.name, traceId: event.traceId });
+        const result = subscriber.handler(event);
+        if (result && typeof result.then === "function") {
+          result.catch((err) => {
+            log.bus.error(`subscriber "${subscriber.name}" threw on event "${name}" (async)`, {
+              eventName: name,
+              traceId: event.traceId,
+              error: err instanceof Error ? err.message : String(err),
+              stack: err instanceof Error ? err.stack : void 0
+            });
+          });
+        }
+      } catch (err) {
+        log.bus.error(`subscriber "${subscriber.name}" threw on event "${name}"`, {
+          eventName: name,
+          traceId: event.traceId,
+          error: err instanceof Error ? err.message : String(err),
+          stack: err instanceof Error ? err.stack : void 0
+        });
+      }
+    }
+  }
+  /**
+   * Check if a subscriber is registered.
+   */
+  has(name) {
+    return this.subscribers.has(name);
+  }
+  /**
+   * Remove all subscribers.
+   */
+  clear() {
+    this.subscribers.clear();
+  }
+};
+var bus = new EventBus();
+
+// src/core/event-loop-monitor.ts
+import { monitorEventLoopDelay } from "perf_hooks";
+import { execFile } from "child_process";
+
+// src/integrations/git-sync.ts
+var LOCAL_TIMEOUT = 3e4;
+var compactionInProgress = false;
+function setCompactionInProgress(v) {
+  compactionInProgress = v;
+}
+var NETWORK_GIT_RE = /^(?:clone|fetch|pull|push|ls-remote)\b/;
+var execAsync = promisify(exec);
+function credentialGuardArgs(cwd) {
+  try {
+    const urls = execSync('git config --get-regexp "remote\\..*\\.url"', {
+      cwd: cwd ?? WALNUT_HOME,
+      timeout: LOCAL_TIMEOUT,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (/https?:\/\/[^/\s]+@/.test(urls)) return ["-c", "credential.helper="];
+  } catch {
+  }
+  return [];
+}
+function git(args, options) {
+  const guard = NETWORK_GIT_RE.test(args) ? credentialGuardArgs(options?.cwd).join(" ") : "";
+  return execSync(`git ${guard ? `${guard} ` : ""}${args}`, {
+    cwd: options?.cwd ?? WALNUT_HOME,
+    timeout: options?.timeout ?? LOCAL_TIMEOUT,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"],
+    env: options?.env ? { ...process.env, ...options.env } : void 0
+  }).trim();
+}
+function gitSafe(args, options) {
+  try {
+    return git(args, options);
+  } catch {
+    return null;
+  }
+}
+var TRACKED_COUNT_TTL_MS = 10 * 6e4;
+var SAFE_MODE_RELOG_MS = 10 * 6e4;
+var SURGERY_RELOG_MS = 10 * 6e4;
+function clearStaleLock(maxAgeMs = 6e4) {
+  const gitDir = path3.join(WALNUT_HOME, ".git");
+  let removed = false;
+  const removeIfStale = (lockPath) => {
+    try {
+      const stat = fs3.statSync(lockPath);
+      if (Date.now() - stat.mtimeMs <= maxAgeMs) return;
+      fs3.unlinkSync(lockPath);
+      removed = true;
+      log.git.warn("git-sync removed stale lock", { lock: path3.relative(gitDir, lockPath) });
+    } catch {
+    }
+  };
+  removeIfStale(path3.join(gitDir, "index.lock"));
+  try {
+    for (const entry of fs3.readdirSync(gitDir)) {
+      if (entry !== "index.lock" && entry.endsWith(".lock")) {
+        removeIfStale(path3.join(gitDir, entry));
+      }
+    }
+  } catch {
+  }
+  const walkRefs = (dir, depth) => {
+    if (depth > 6) return;
+    let entries;
+    try {
+      entries = fs3.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path3.join(dir, entry.name);
+      if (entry.isDirectory()) walkRefs(full, depth + 1);
+      else if (entry.name.endsWith(".lock")) removeIfStale(full);
+    }
+  };
+  walkRefs(path3.join(gitDir, "refs"), 0);
+  return removed;
+}
+var REPO_SIZE_WARN_BYTES = 3 * 1024 * 1024 * 1024;
+var REPO_SIZE_CHECK_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+
+// src/integrations/git-compaction.ts
+function statePath(repoDir) {
+  return path4.join(repoDir, ".git", "compaction-state.json");
+}
+function writeState(repoDir, state) {
+  fs4.writeFileSync(statePath(repoDir), JSON.stringify(state), "utf-8");
+}
+function removeState(repoDir) {
+  try {
+    fs4.unlinkSync(statePath(repoDir));
+  } catch {
+  }
+}
+function isoWeek(dateStr) {
+  const d = new Date(dateStr);
+  const jan4 = new Date(d.getFullYear(), 0, 4);
+  const dayOfYear = Math.floor((d.getTime() - new Date(d.getFullYear(), 0, 1).getTime()) / 864e5) + 1;
+  const dayOfWeek = d.getDay() || 7;
+  const weekNum = Math.floor((dayOfYear - dayOfWeek + 10) / 7);
+  if (weekNum < 1) {
+    return `${d.getFullYear() - 1}-W52`;
+  }
+  return `${d.getFullYear()}-W${String(weekNum).padStart(2, "0")}`;
+}
+function selectCommits(commits, config) {
+  const now = Date.now();
+  const DAY = 864e5;
+  const recent = [];
+  const dailyBuckets = /* @__PURE__ */ new Map();
+  const weeklyBuckets = /* @__PURE__ */ new Map();
+  for (const c of commits) {
+    const ageDays = (now - new Date(c.date).getTime()) / DAY;
+    if (ageDays < config.recentDays) {
+      recent.push(c);
+    } else if (ageDays < config.dailyDays) {
+      dailyBuckets.set(c.date.slice(0, 10), c);
+    } else {
+      weeklyBuckets.set(isoWeek(c.date), c);
+    }
+  }
+  return [
+    ...weeklyBuckets.values(),
+    ...dailyBuckets.values(),
+    ...recent
+  ];
+}
+function parseGitLog(raw) {
+  if (!raw.trim()) return [];
+  return raw.split("\n").map((line) => {
+    const spaceIdx1 = line.indexOf(" ");
+    const spaceIdx2 = line.indexOf(" ", spaceIdx1 + 1);
+    return {
+      hash: line.slice(0, spaceIdx1),
+      date: line.slice(spaceIdx1 + 1, spaceIdx2),
+      subject: line.slice(spaceIdx2 + 1)
+    };
+  });
+}
+var LOG_PAGE_SIZE = 5e3;
+function collectCommitsPaged(repoDir) {
+  const opts = { cwd: repoDir };
+  const pages = [];
+  for (let skip = 0; ; skip += LOG_PAGE_SIZE) {
+    const raw = git(
+      `log --format="%H %aI %s" --max-count=${LOG_PAGE_SIZE} --skip=${skip}`,
+      opts
+    );
+    const page = parseGitLog(raw);
+    if (page.length === 0) break;
+    pages.push(page);
+    if (page.length < LOG_PAGE_SIZE) break;
+  }
+  return pages.flat().reverse();
+}
+function compactGitHistory(repoDir = WALNUT_HOME) {
+  const opts = { cwd: repoDir };
+  const branch = gitSafe("rev-parse --abbrev-ref HEAD", opts);
+  if (branch !== "main") {
+    git("checkout main", opts);
+  }
+  const hasRemote = (gitSafe("remote", opts) ?? "").length > 0;
+  let remoteHeadBeforeRewrite = null;
+  if (hasRemote) {
+    if (gitSafe("fetch origin main", opts) === null) {
+      log.git.warn("compaction deferred: remote unreachable (rewriting without pushing would wedge sync)");
+      return { skipped: true, before: 0, after: 0 };
+    }
+    remoteHeadBeforeRewrite = gitSafe("rev-parse origin/main", opts);
+    if (remoteHeadBeforeRewrite && gitSafe(`merge-base --is-ancestor ${remoteHeadBeforeRewrite} main`, opts) === null) {
+      log.git.warn("compaction deferred: origin/main has commits not merged locally \u2014 sync must catch up first");
+      return { skipped: true, before: 0, after: 0 };
+    }
+  }
+  const commits = collectCommitsPaged(repoDir);
+  if (commits.length < 50) {
+    return { skipped: true, before: commits.length, after: commits.length };
+  }
+  const selected = selectCommits(commits, { recentDays: 7, dailyDays: 30 });
+  if (selected.length >= commits.length * 0.9) {
+    return { skipped: true, before: commits.length, after: selected.length };
+  }
+  const backupName = `backup-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10).replace(/-/g, "")}`;
+  gitSafe(`branch -D ${backupName}`, opts);
+  git(`branch ${backupName}`, opts);
+  writeState(repoDir, { phase: "building", backup: backupName, startedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  try {
+    let parent = "";
+    let newHead = "";
+    for (const commit of selected) {
+      const safeSubject = commit.subject.replace(/"/g, '\\"');
+      const message = commit === selected[0] && selected.length < commits.length ? `compacted: ${safeSubject}` : safeSubject;
+      newHead = git(
+        `commit-tree ${commit.hash}^{tree}${parent ? ` -p ${parent}` : ""} -m "${message}"`,
+        {
+          ...opts,
+          env: {
+            GIT_AUTHOR_DATE: commit.date,
+            GIT_COMMITTER_DATE: commit.date
+          }
+        }
+      );
+      parent = newHead;
+    }
+    git(`update-ref refs/heads/compaction-wip ${newHead}`, opts);
+    writeState(repoDir, { phase: "verified", backup: backupName, startedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    const wipTree = gitSafe("rev-parse compaction-wip^{tree}", opts);
+    const mainTree = gitSafe("rev-parse main^{tree}", opts);
+    if (!wipTree || wipTree !== mainTree) {
+      gitSafe("update-ref -d refs/heads/compaction-wip", opts);
+      removeState(repoDir);
+      return { before: commits.length, after: commits.length, error: "verification failed: trees differ" };
+    }
+    git(`update-ref refs/heads/main ${newHead}`, opts);
+    gitSafe("reset --mixed HEAD", opts);
+    gitSafe("update-ref -d refs/heads/compaction-wip", opts);
+    writeState(repoDir, { phase: "swapped", backup: backupName, startedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    if (hasRemote) {
+      const lease = remoteHeadBeforeRewrite ? `--force-with-lease=refs/heads/main:${remoteHeadBeforeRewrite}` : "--force-with-lease";
+      if (gitSafe(`push ${lease} origin main`, { ...opts, timeout: 12e4 }) === null) {
+        log.git.warn("compaction: force-with-lease push failed \u2014 restoring pre-compaction main so sync stays consistent with the hub");
+        git(`update-ref refs/heads/main ${backupName}`, opts);
+        gitSafe("reset --mixed HEAD", opts);
+        removeState(repoDir);
+        return { before: commits.length, after: commits.length, error: "push of compacted history failed (lease lost or network) \u2014 rolled back, will retry next run" };
+      }
+    }
+    writeState(repoDir, { phase: "cleaning", backup: backupName, startedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    try {
+      git("reflog expire --expire=now --all", opts);
+      git("gc --prune=now", opts);
+    } catch {
+    }
+    deleteOldBackups(repoDir, 2);
+    removeState(repoDir);
+    return { before: commits.length, after: selected.length };
+  } catch (err) {
+    const currentBranch = gitSafe("rev-parse --abbrev-ref HEAD", opts);
+    if (currentBranch !== "main") {
+      gitSafe("checkout main", opts);
+    }
+    const mainExists = gitSafe("rev-parse --verify main", opts);
+    if (!mainExists) {
+      gitSafe(`branch main ${backupName}`, opts);
+      gitSafe("checkout main", opts);
+    }
+    gitSafe("branch -D compaction-wip", opts);
+    removeState(repoDir);
+    throw err;
+  }
+}
+function deleteOldBackups(repoDir, keepCount) {
+  const opts = { cwd: repoDir };
+  const branches = gitSafe("branch --list backup-*", opts);
+  if (!branches) return;
+  const backupBranches = branches.split("\n").map((b) => b.trim()).filter((b) => b.startsWith("backup-")).sort();
+  const toDelete = backupBranches.slice(0, -keepCount);
+  for (const b of toDelete) {
+    gitSafe(`branch -D ${b}`, opts);
+  }
+}
+var LAST_COMPACTION_FILE = ".last-compaction";
+var COMPACTION_INTERVAL_DAYS = 7;
+function isCompactionDue(repoDir = WALNUT_HOME) {
+  const filePath = path4.join(repoDir, LAST_COMPACTION_FILE);
+  try {
+    const content = fs4.readFileSync(filePath, "utf-8").trim();
+    const lastDate = new Date(content);
+    const daysSince = (Date.now() - lastDate.getTime()) / 864e5;
+    return daysSince >= COMPACTION_INTERVAL_DAYS;
+  } catch {
+    return true;
+  }
+}
+function markCompactionDone(repoDir = WALNUT_HOME) {
+  fs4.writeFileSync(
+    path4.join(repoDir, LAST_COMPACTION_FILE),
+    (/* @__PURE__ */ new Date()).toISOString(),
+    "utf-8"
+  );
+}
+function runScheduledCompaction(repoDir = WALNUT_HOME) {
+  if (!isCompactionDue(repoDir)) return null;
+  setCompactionInProgress(true);
+  try {
+    clearStaleLock();
+    const result = compactGitHistory(repoDir);
+    if (!result.skipped && !result.error) {
+      markCompactionDone(repoDir);
+    }
+    return result;
+  } finally {
+    setCompactionInProgress(false);
+  }
+}
+
+// src/workers/git-compaction-worker.ts
+initLogging();
+try {
+  const result = runScheduledCompaction();
+  if (process.connected) process.send?.({ ok: true, result });
+  process.exit(0);
+} catch (err) {
+  const message = err instanceof Error ? err.message : String(err);
+  log.git.warn("compaction worker failed", { error: message });
+  if (process.connected) process.send?.({ ok: false, error: message });
+  process.exit(1);
+}
+//# sourceMappingURL=git-compaction-worker.js.map