codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/file-watcher.js

@@ -0,0 +1,193 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var file_watcher_exports = {};
+__export(file_watcher_exports, {
+  startWatching: () => startWatching,
+  stopWatching: () => stopWatching
+});
+module.exports = __toCommonJS(file_watcher_exports);
+var _lazy___cross_system_service = __toESM(require("./cross-system-service"));
+var _lazy___plan_progress_service = __toESM(require("./plan-progress-service"));
+var import_tree_watcher = require("./tree-watcher");
+var import_node_path = __toESM(require("node:path"));
+var import_ast_parser = require("./ast-parser");
+var import_database = require("./database");
+var import_server = require("../server");
+var import_deviation_service = require("./deviation-service");
+var import_sensor_bridge_service = require("./sensor-bridge-service");
+var import_stuck_sensor_service = require("./stuck-sensor-service");
+var import_workstream_watch_service = require("./workstream-watch-service");
+var import_watch_ignore = require("./watch-ignore");
+let watcher = null;
+const READY_TIMEOUT_MS = 1e4;
+let crossSystemRecomputeTimer = null;
+const CROSS_SYSTEM_DEBOUNCE_MS = 500;
+function scheduleCrossSystemRecompute() {
+  if (crossSystemRecomputeTimer) clearTimeout(crossSystemRecomputeTimer);
+  crossSystemRecomputeTimer = setTimeout(() => {
+    crossSystemRecomputeTimer = null;
+    try {
+      const { recomputeCrossSystemEdges } = _lazy___cross_system_service;
+      recomputeCrossSystemEdges();
+      try {
+        (0, import_server.broadcast)("cross-system-changed", { reason: "file-change" });
+      } catch {
+      }
+    } catch (err) {
+      console.warn("[Watcher] Cross-system recompute failed:", err);
+    }
+  }, CROSS_SYSTEM_DEBOUNCE_MS);
+}
+const PARSEABLE_EXTS = new Set((0, import_ast_parser.getParseableExtensions)());
+async function startWatching(projectRoot) {
+  await (0, import_ast_parser.initParser)();
+  if (watcher) {
+    await watcher.close();
+  }
+  (0, import_workstream_watch_service.setExternallyWatchedFolder)(projectRoot);
+  watcher = (0, import_tree_watcher.watchTree)(projectRoot, {
+    ...(0, import_watch_ignore.checkoutWatchOptions)(projectRoot),
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 300,
+      pollInterval: 100
+    }
+  });
+  watcher.on("error", (err) => {
+    console.warn("[Watcher] error (continuing):", err);
+  });
+  watcher.on("change", (filePath) => {
+    (0, import_workstream_watch_service.nudgeWorkstream)(projectRoot);
+    const ext = import_node_path.default.extname(filePath).toLowerCase();
+    if (!PARSEABLE_EXTS.has(ext)) return;
+    const parsed = (0, import_ast_parser.parseFile)(filePath);
+    if (!parsed) return;
+    const oldHash = (0, import_database.getFileHash)(filePath);
+    if (oldHash === parsed.contentHash) return;
+    (0, import_database.storeParsedFile)(parsed, projectRoot);
+    (0, import_database.resolvePendingImports)(projectRoot);
+    console.log(`[Watcher] Re-parsed: ${import_node_path.default.relative(projectRoot, filePath)}`);
+    const relativePath = import_node_path.default.relative(projectRoot, filePath);
+    (0, import_server.broadcast)("file-changed", {
+      path: filePath,
+      relativePath,
+      symbols: parsed.symbols.map((s) => ({ name: s.name, kind: s.kind }))
+    });
+    try {
+      (0, import_deviation_service.checkFileDeviation)(relativePath);
+    } catch {
+    }
+    try {
+      const { recordFileChange } = _lazy___plan_progress_service;
+      recordFileChange(relativePath);
+    } catch {
+    }
+    try {
+      (0, import_sensor_bridge_service.checkDocFreshnessForFile)(relativePath, projectRoot);
+    } catch {
+    }
+    try {
+      (0, import_stuck_sensor_service.recordFileActivity)(projectRoot);
+    } catch {
+    }
+    scheduleCrossSystemRecompute();
+  });
+  watcher.on("add", (filePath) => {
+    (0, import_workstream_watch_service.nudgeWorkstream)(projectRoot);
+    const ext = import_node_path.default.extname(filePath).toLowerCase();
+    if (!PARSEABLE_EXTS.has(ext)) return;
+    const parsed = (0, import_ast_parser.parseFile)(filePath);
+    if (!parsed) return;
+    (0, import_database.storeParsedFile)(parsed, projectRoot);
+    (0, import_database.resolvePendingImports)(projectRoot);
+    console.log(`[Watcher] New file parsed: ${import_node_path.default.relative(projectRoot, filePath)}`);
+    (0, import_server.broadcast)("file-added", {
+      path: filePath,
+      relativePath: import_node_path.default.relative(projectRoot, filePath)
+    });
+    const relPath = import_node_path.default.relative(projectRoot, filePath);
+    try {
+      (0, import_deviation_service.checkFileDeviation)(relPath);
+    } catch {
+    }
+    try {
+      const { recordFileChange } = _lazy___plan_progress_service;
+      recordFileChange(relPath);
+    } catch {
+    }
+    try {
+      (0, import_sensor_bridge_service.checkDocFreshnessForFile)(relPath, projectRoot);
+    } catch {
+    }
+    try {
+      (0, import_stuck_sensor_service.recordFileActivity)(projectRoot);
+    } catch {
+    }
+    scheduleCrossSystemRecompute();
+  });
+  watcher.on("unlink", (filePath) => {
+    (0, import_workstream_watch_service.nudgeWorkstream)(projectRoot);
+    console.log(`[Watcher] File removed: ${import_node_path.default.relative(projectRoot, filePath)}`);
+    try {
+      (0, import_database.removeStaleFiles)([filePath]);
+    } catch (err) {
+      console.warn("[Watcher] Could not drop removed file:", err);
+    }
+    (0, import_server.broadcast)("file-removed", { path: filePath });
+    scheduleCrossSystemRecompute();
+  });
+  const readyWatcher = watcher;
+  await new Promise((resolve) => {
+    let settled = false;
+    const done = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(guard);
+      resolve();
+    };
+    const guard = setTimeout(() => {
+      console.warn(`[Watcher] Initial walk still running after ${READY_TIMEOUT_MS}ms \u2014 continuing`);
+      done();
+    }, READY_TIMEOUT_MS);
+    guard.unref?.();
+    readyWatcher.once("ready", done);
+  });
+  console.log(`[Watcher] Watching ${projectRoot}`);
+}
+async function stopWatching() {
+  if (watcher) {
+    await watcher.close();
+    watcher = null;
+  }
+  (0, import_workstream_watch_service.setExternallyWatchedFolder)(null);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startWatching,
+  stopWatching
+});

package/src/backend/services/folder-requests.js

@@ -0,0 +1,118 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var folder_requests_exports = {};
+__export(folder_requests_exports, {
+  clearFolderRequests: () => clearFolderRequests,
+  dismissFolderRequest: () => dismissFolderRequest,
+  listFolderRequests: () => listFolderRequests,
+  normaliseReportedFolder: () => normaliseReportedFolder,
+  recordFolderRequest: () => recordFolderRequest,
+  rememberDismissal: () => rememberDismissal,
+  setFolderRequestsListener: () => setFolderRequestsListener,
+  takeFolderRequest: () => takeFolderRequest
+});
+module.exports = __toCommonJS(folder_requests_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_node_crypto = require("node:crypto");
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+const pending = /* @__PURE__ */ new Map();
+let onChanged = () => {
+};
+function setFolderRequestsListener(listener) {
+  onChanged = listener;
+}
+function normaliseReportedFolder(raw) {
+  if (typeof raw !== "string" || raw.length === 0 || raw.length > 4096 || raw.includes("\0") || !import_node_path.default.isAbsolute(raw)) return null;
+  return import_node_path.default.resolve(raw);
+}
+function isDismissed(folder) {
+  try {
+    return !!(0, import_database.getDb)().exec(`SELECT 1 FROM folder_request_dismissals WHERE folder = ?`, [folder])[0]?.values[0];
+  } catch {
+    return false;
+  }
+}
+function recordFolderRequest(input, now = Date.now()) {
+  const folder = normaliseReportedFolder(input.folder);
+  if (!folder || isDismissed(folder)) return null;
+  const existing = [...pending.values()].find((r) => r.folder === folder);
+  if (existing) {
+    if (!existing.sessionIds.includes(input.sessionId)) existing.sessionIds.push(input.sessionId);
+    return existing;
+  }
+  const req = {
+    id: (0, import_node_crypto.randomBytes)(8).toString("hex"),
+    folder,
+    agentType: input.agentType,
+    sessionIds: [input.sessionId],
+    reportedAt: now
+  };
+  pending.set(req.id, req);
+  onChanged();
+  return req;
+}
+function listFolderRequests() {
+  return [...pending.values()].sort((a, b) => a.reportedAt - b.reportedAt);
+}
+function takeFolderRequest(id) {
+  const req = pending.get(id) ?? null;
+  if (req) {
+    pending.delete(id);
+    onChanged();
+  }
+  return req;
+}
+function dismissFolderRequest(id, now = Date.now()) {
+  const req = takeFolderRequest(id);
+  if (!req) return false;
+  rememberDismissal(req.folder, now);
+  return true;
+}
+function rememberDismissal(folder, now = Date.now()) {
+  (0, import_database.getDb)().run(
+    `INSERT INTO folder_request_dismissals (folder, dismissed_at) VALUES (?, ?)
+     ON CONFLICT(folder) DO UPDATE SET dismissed_at = excluded.dismissed_at`,
+    [folder, now]
+  );
+  (0, import_persistence.markDirty)();
+}
+function clearFolderRequests() {
+  pending.clear();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearFolderRequests,
+  dismissFolderRequest,
+  listFolderRequests,
+  normaliseReportedFolder,
+  recordFolderRequest,
+  rememberDismissal,
+  setFolderRequestsListener,
+  takeFolderRequest
+});

package/src/backend/services/freeze-service.js

@@ -0,0 +1,189 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var freeze_service_exports = {};
+__export(freeze_service_exports, {
+  acknowledgeFreezeChange: () => acknowledgeFreezeChange,
+  exemptPlanFromFreeze: () => exemptPlanFromFreeze,
+  flaggedFreezeChanges: () => flaggedFreezeChanges,
+  getFreezeStatus: () => getFreezeStatus,
+  isPlanAllowedDuringFreeze: () => isPlanAllowedDuringFreeze,
+  listFreezeChanges: () => listFreezeChanges,
+  setFreeze: () => setFreeze
+});
+module.exports = __toCommonJS(freeze_service_exports);
+var import_project_config_service = require("./project-config-service");
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_budget_service = require("./budget-service");
+function getFreezeStatus(projectRoot) {
+  return { ...freezeState(projectRoot), flaggedChanges: flaggedFreezeChanges(projectRoot) };
+}
+function freezeState(projectRoot) {
+  const cfg = (0, import_project_config_service.getProjectConfig)(projectRoot);
+  const freeze = cfg.freeze;
+  if (!freeze || !freeze.active) {
+    return {
+      active: false,
+      reason: freeze?.reason ?? null,
+      since: freeze?.since ?? null,
+      until: freeze?.until ?? null,
+      expired: false,
+      allowedPlanUids: freeze?.allowedPlanUids ?? [],
+      elapsedMs: null,
+      remainingMs: null
+    };
+  }
+  const now = Date.now();
+  const sinceMs = freeze.since ? new Date(freeze.since).getTime() : null;
+  const untilMs = freeze.until ? new Date(freeze.until).getTime() : null;
+  const expired = untilMs !== null && now > untilMs;
+  return {
+    active: !expired,
+    reason: freeze.reason ?? null,
+    since: freeze.since ?? null,
+    until: freeze.until ?? null,
+    expired,
+    allowedPlanUids: freeze.allowedPlanUids ?? [],
+    elapsedMs: sinceMs ? now - sinceMs : null,
+    remainingMs: untilMs && !expired ? untilMs - now : null
+  };
+}
+function setFreeze(projectRoot, opts, by) {
+  const before = currentSettings(projectRoot);
+  const patch = {
+    freeze: {
+      active: opts.active,
+      reason: opts.reason,
+      since: opts.active ? (/* @__PURE__ */ new Date()).toISOString() : void 0,
+      until: opts.until ?? null,
+      allowedPlanUids: opts.allowedPlanUids ?? []
+    }
+  };
+  if (!opts.active) {
+    const cfg = (0, import_project_config_service.getProjectConfig)(projectRoot);
+    const existing = cfg.freeze;
+    patch.freeze.since = existing?.since ?? void 0;
+  }
+  (0, import_project_config_service.updateProjectConfig)(projectRoot, patch);
+  recordFreezeChange(projectRoot, before, by);
+  return getFreezeStatus(projectRoot);
+}
+function isPlanAllowedDuringFreeze(projectRoot, planUid) {
+  const status = getFreezeStatus(projectRoot);
+  if (!status.active) return true;
+  return status.allowedPlanUids.includes(planUid);
+}
+function exemptPlanFromFreeze(projectRoot, planUid, by) {
+  const before = currentSettings(projectRoot);
+  const cfg = (0, import_project_config_service.getProjectConfig)(projectRoot);
+  const freeze = cfg.freeze;
+  const current = freeze?.allowedPlanUids ?? [];
+  if (current.includes(planUid)) {
+    return getFreezeStatus(projectRoot);
+  }
+  const patch = {
+    freeze: {
+      ...freeze ?? { active: false },
+      allowedPlanUids: [...current, planUid]
+    }
+  };
+  (0, import_project_config_service.updateProjectConfig)(projectRoot, patch);
+  recordFreezeChange(projectRoot, before, by);
+  return getFreezeStatus(projectRoot);
+}
+function currentSettings(projectRoot) {
+  const freeze = (0, import_project_config_service.getProjectConfig)(projectRoot).freeze;
+  if (!freeze) return null;
+  return {
+    active: Boolean(freeze.active),
+    reason: freeze.reason ?? null,
+    until: freeze.until ?? null,
+    allowedPlanUids: [...freeze.allowedPlanUids ?? []]
+  };
+}
+const sameSettings = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+const NOT_FROZEN = { active: false, reason: null, until: null, allowedPlanUids: [] };
+function recordFreezeChange(projectRoot, before, by) {
+  if (!by) return;
+  const after = currentSettings(projectRoot) ?? NOT_FROZEN;
+  if (sameSettings(before ?? NOT_FROZEN, after)) return;
+  try {
+    (0, import_database.getDb)().run(
+      `INSERT INTO project_freeze_changes (project_path, actor, actor_type, channel, before_json, after_json, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [projectRoot, by.actor, by.actorType, by.channel, before ? JSON.stringify(before) : null, JSON.stringify(after), Date.now()]
+    );
+    (0, import_persistence.markDirty)();
+  } catch (err) {
+    console.warn("[Freeze] could not record the change:", err);
+  }
+}
+const CHANGE_COLUMNS = "id, project_path, actor, actor_type, channel, before_json, after_json, created_at, acknowledged_at, acknowledged_by";
+function toChange(r) {
+  const actorType = r[3];
+  const acknowledgedAt = r[8] ?? null;
+  return {
+    id: r[0],
+    projectPath: r[1],
+    actor: r[2],
+    actorType,
+    channel: r[4],
+    before: r[5] ? JSON.parse(r[5]) : null,
+    after: JSON.parse(r[6]),
+    at: r[7],
+    flagged: (0, import_budget_service.isFlaggedActor)(actorType) && acknowledgedAt === null,
+    acknowledgedAt,
+    acknowledgedBy: r[9] ?? null
+  };
+}
+function listFreezeChanges(projectRoot, limit = 50) {
+  try {
+    const res = (0, import_database.getDb)().exec(
+      `SELECT ${CHANGE_COLUMNS} FROM project_freeze_changes WHERE project_path = ? ORDER BY created_at DESC, id DESC LIMIT ?`,
+      [projectRoot, limit]
+    );
+    return (res[0]?.values ?? []).map(toChange);
+  } catch {
+    return [];
+  }
+}
+function flaggedFreezeChanges(projectRoot) {
+  return listFreezeChanges(projectRoot, 500).filter((c) => c.flagged).reverse();
+}
+function acknowledgeFreezeChange(projectRoot, id, by) {
+  const db = (0, import_database.getDb)();
+  db.run(
+    `UPDATE project_freeze_changes SET acknowledged_at = ?, acknowledged_by = ?
+     WHERE project_path = ? AND id = ? AND acknowledged_at IS NULL`,
+    [Date.now(), by, projectRoot, id]
+  );
+  (0, import_persistence.markDirty)();
+  const res = db.exec(`SELECT ${CHANGE_COLUMNS} FROM project_freeze_changes WHERE project_path = ? AND id = ?`, [projectRoot, id]);
+  const row = res[0]?.values[0];
+  return row ? toChange(row) : null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  acknowledgeFreezeChange,
+  exemptPlanFromFreeze,
+  flaggedFreezeChanges,
+  getFreezeStatus,
+  isPlanAllowedDuringFreeze,
+  listFreezeChanges,
+  setFreeze
+});

package/src/backend/services/gemini-cli-hook.js

@@ -0,0 +1,172 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var gemini_cli_hook_exports = {};
+__export(gemini_cli_hook_exports, {
+  GEMINI_HOOK_NAME: () => GEMINI_HOOK_NAME,
+  GEMINI_HOOK_TIMEOUT_MS: () => GEMINI_HOOK_TIMEOUT_MS,
+  GEMINI_SETTINGS_FILE: () => GEMINI_SETTINGS_FILE,
+  applyGeminiHook: () => applyGeminiHook,
+  geminiDir: () => geminiDir,
+  geminiHookCommand: () => geminiHookCommand,
+  planGeminiHook: () => planGeminiHook,
+  previewGeminiHook: () => previewGeminiHook,
+  thisMachine: () => thisMachine
+});
+module.exports = __toCommonJS(gemini_cli_hook_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_command = require("../mcp/connector/command");
+var import_hook = require("../mcp/connector/hook");
+var import_claude_desktop_config = require("./claude-desktop-config");
+var import_confined_fs = require("./confined-fs");
+const GEMINI_SETTINGS_FILE = "settings.json";
+const GEMINI_HOOK_TIMEOUT_MS = 1e4;
+const GEMINI_HOOK_NAME = "codetrellis-breakpoints";
+function geminiDir(w) {
+  const dir = import_node_path.default.join(w.env.GEMINI_CLI_HOME?.trim() || w.home, ".gemini");
+  return w.exists(dir) ? dir : null;
+}
+const psQuote = (arg) => `'${arg.replace(/'/g, "''")}'`;
+function geminiHookCommand(connector, platform = process.platform) {
+  if (platform === "win32") {
+    return ["&", psQuote(connector.command), ...connector.args.map(psQuote), import_hook.HOOK_FLAG, import_hook.HOOK_GEMINI_BEFORE_TOOL].join(" ");
+  }
+  return [(0, import_command.shellQuote)(connector.command, "linux"), ...connector.args.map((a) => (0, import_command.shellQuote)(a, "linux")), import_hook.HOOK_FLAG, import_hook.HOOK_GEMINI_BEFORE_TOOL].join(" ");
+}
+const isOurHook = (h) => !!h && typeof h === "object" && typeof h.command === "string" && /mcp-connector\.cjs/.test(h.command) && h.command.includes(`${import_hook.HOOK_FLAG} ${import_hook.HOOK_GEMINI_BEFORE_TOOL}`);
+function planGeminiHook(current, command, env = {}) {
+  let doc = {};
+  if (current !== null && current.trim() !== "") {
+    let parsed;
+    try {
+      parsed = JSON.parse(current);
+    } catch {
+      return { ok: false, reason: "Gemini CLI's settings.json is not valid JSON, so it was left alone. Fix it, then try again." };
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { ok: false, reason: "Gemini CLI's settings.json is not a JSON object, so it was left alone." };
+    }
+    doc = parsed;
+  }
+  const hooks = doc.hooks ?? {};
+  if (!hooks || typeof hooks !== "object" || Array.isArray(hooks)) {
+    return { ok: false, reason: `Gemini CLI's settings have a "hooks" that is not an object, so they were left alone.` };
+  }
+  const before = hooks.BeforeTool ?? [];
+  if (!Array.isArray(before)) {
+    return { ok: false, reason: `Gemini CLI's settings have a "BeforeTool" that is not a list, so they were left alone.` };
+  }
+  const ours = { type: "command", name: GEMINI_HOOK_NAME, command, ...Object.keys(env).length ? { env } : {}, timeout: GEMINI_HOOK_TIMEOUT_MS };
+  let placed = false;
+  const kept = before.flatMap((group) => {
+    const g = group;
+    if (!g || typeof g !== "object" || !Array.isArray(g.hooks) || !g.hooks.some(isOurHook)) return [group];
+    const others = g.hooks.filter((h) => !isOurHook(h));
+    const mine = placed ? [] : [{ matcher: import_hook.GEMINI_HOOK_MATCHER, hooks: [ours] }];
+    placed = true;
+    return [...mine, ...others.length ? [{ ...g, hooks: others }] : []];
+  });
+  const next = placed ? kept : [...kept, { matcher: import_hook.GEMINI_HOOK_MATCHER, hooks: [ours] }];
+  const merged = { ...doc, hooks: { ...hooks, BeforeTool: next } };
+  const text = current ?? "";
+  const unchanged = current !== null && JSON.stringify(JSON.parse(current || "{}")) === JSON.stringify(merged);
+  const after = unchanged ? text : `${JSON.stringify(merged, null, 2)}
+`;
+  const status = text === after ? "unchanged" : current !== null ? "update" : "add";
+  return { ok: true, status, before: text, after, diff: status === "unchanged" ? [] : (0, import_claude_desktop_config.lineDiff)(text, after) };
+}
+const NO_DIR = "Gemini CLI's settings folder (~/.gemini) was not found on this computer. Install Gemini CLI and run it once, then try again.";
+const NO_CONNECTOR = "The connector is not built in this checkout, so there is no hook to add yet (npm run build:connector).";
+function readCurrent(dir) {
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(dir, GEMINI_SETTINGS_FILE))) return { text: null };
+  try {
+    return { text: (0, import_confined_fs.readTextWithin)(dir, GEMINI_SETTINGS_FILE, "Gemini CLI settings") };
+  } catch {
+    return { error: "Gemini CLI's settings.json could not be read (it may be a link, which is not followed), so it was left alone." };
+  }
+}
+function previewGeminiHook(where, connector) {
+  const dir = geminiDir(where);
+  if (!dir) return { ok: false, reason: NO_DIR };
+  if (!connector) return { ok: false, reason: NO_CONNECTOR };
+  const current = readCurrent(dir);
+  if ("error" in current) return { ok: false, reason: current.error };
+  const plan = planGeminiHook(current.text, geminiHookCommand(connector), connector.env);
+  if (!plan.ok) return plan;
+  return {
+    ok: true,
+    dir,
+    path: import_node_path.default.join(dir, GEMINI_SETTINGS_FILE),
+    status: plan.status,
+    diff: plan.diff,
+    beforeHash: (0, import_claude_desktop_config.hashOf)(current.text),
+    exists: current.text !== null,
+    ...connector.caveat ? { caveat: connector.caveat } : {}
+  };
+}
+const stampOf = (now) => now.toISOString().replace(/[:.]/g, "-");
+function applyGeminiHook(where, connector, shownHash, now = /* @__PURE__ */ new Date()) {
+  const dir = geminiDir(where);
+  if (!dir) return { ok: false, reason: NO_DIR };
+  if (!connector) return { ok: false, reason: NO_CONNECTOR };
+  const current = readCurrent(dir);
+  if ("error" in current) return { ok: false, reason: current.error };
+  if ((0, import_claude_desktop_config.hashOf)(current.text) !== shownHash) {
+    return { ok: false, changed: true, reason: "Gemini CLI's settings.json changed after you looked at it. Here is the change again, against the file as it is now." };
+  }
+  const plan = planGeminiHook(current.text, geminiHookCommand(connector), connector.env);
+  if (!plan.ok) return plan;
+  const target = import_node_path.default.join(dir, GEMINI_SETTINGS_FILE);
+  if (plan.status === "unchanged") return { ok: true, path: target, backupPath: null, status: "unchanged" };
+  try {
+    let backupPath = null;
+    if (current.text !== null) {
+      backupPath = (0, import_confined_fs.writeFileWithin)(dir, `settings.before-codetrellis-${stampOf(now)}.json`, current.text, "Gemini CLI settings backup");
+    }
+    (0, import_confined_fs.writeFileWithin)(dir, GEMINI_SETTINGS_FILE, plan.after, "Gemini CLI settings");
+    return { ok: true, path: target, backupPath, status: plan.status };
+  } catch {
+    return { ok: false, reason: "Gemini CLI's settings.json could not be written (a link at its place is not written through)." };
+  }
+}
+function thisMachine() {
+  return { home: import_node_os.default.homedir(), env: process.env, exists: (p) => import_node_fs.default.existsSync(p) };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GEMINI_HOOK_NAME,
+  GEMINI_HOOK_TIMEOUT_MS,
+  GEMINI_SETTINGS_FILE,
+  applyGeminiHook,
+  geminiDir,
+  geminiHookCommand,
+  planGeminiHook,
+  previewGeminiHook,
+  thisMachine
+});