@mattstack/rt-client 0.3.0 → 0.4.1

package/src/settings/registry-defs.ts

@@ -136,7 +136,7 @@ export const REGISTRY: readonly SettingDef[] = [
     merge: "deep",
     repoScoped: true,
     migrated: true,
-    description: "Branch-naming templates. rt itself has no readers of this key yet — the VS Code extension still reads repos/<repo>/branch-naming.json by repo name, which stays authoritative until the extension ports over. Setting this key stores a value nothing consumes.",
+    description: "Branch-naming templates, repoScoped. Read by the VS Code extension (extensions/vscode/rt-context), which lazily imports the legacy repos/<repo>/branch-naming.json into this key on first read; rt itself has no CLI-side reader.",
   },
   {
     key: "rt.variations",
@@ -196,17 +196,14 @@ export const REGISTRY: readonly SettingDef[] = [
     migrated: true,
     description: "Age floor in days for the log janitor pruning every surface's rotated log files under ~/.mattstack/rt/logs (default 14). A fresh key, not an ownership-latch port, so a default is fine here.",
   },
-
-  // --- migrated:false (deferred by ruling) --------------------------------
   {
     key: "rt.hooks",
     type: "object",
     scopes: ALL_SCOPES,
     merge: "deep",
     repoScoped: true,
-    migrated: false,
-    legacyFile: "repos/<repo>/hooks.json",
-    description: "User-defined lifecycle hooks rt runs around commands (pre/post command scripts).",
+    migrated: true,
+    description: "Per-repo git hook enable/disable state ({enabled, hooks: {<hookName>: boolean}}); ownership-latch port of repos/<repo>/hooks.json, store wins per field once it owns the key — including per-hook-name entries inside the nested hooks map, each defaulting to enabled when absent. The installed git-hook shim still greps repos/<repo>/hooks.json with zero process spawns (a hook fires on every git operation); that file is now a DERIVED CACHE this key writes through, kept current by commands/hooks.ts's regenerateHooksCache at every write seam.",
   },
 
   // --- mattstack (installer-lane) -----------------------------------------
@@ -231,6 +228,15 @@ export const REGISTRY: readonly SettingDef[] = [
     merge: "replace",
     description: "Absolute path to the installed mattstack.app bundle, written by the app at launch so rt stops hardcoding ~/Applications.",
   },
+  {
+    key: "rt.integrations",
+    type: "object",
+    scopes: ["user"],
+    merge: "deep",
+    migrated: true,
+    description:
+      "User-confirmed integration hosts (forgeHost, switchboardUrl), written only by an explicit `rt setup <id> connect --host` after that host validates a real credential. The one trusted source a credential is ever sent to — mattstack.integrations' team-declared host is shown to the user but never auto-used for a fetch.",
+  },
 
   // --- claude (installer-lane) --------------------------------------------
   {
@@ -436,4 +442,35 @@ export const REGISTRY: readonly SettingDef[] = [
     merge: "deep",
     description: "gitq checkout-board config: tracked repos, local port, and the herdr workspace it launches into.",
   },
+
+  // --- chat (RT-48 Task 7) -------------------------------------------------
+  {
+    key: "chat.handle",
+    type: "string",
+    scopes: ["user"],
+    merge: "replace",
+    description: "Explicit rt chat handle for this developer on this machine; overrides the derived <repo>-<dir> handle when set.",
+  },
+  {
+    key: "chat.humanHandle",
+    type: "string",
+    scopes: ["user"],
+    default: "matt",
+    merge: "replace",
+    description: "The human's own chat handle, so agents can @-mention them by name.",
+  },
+  {
+    key: "chat.push.provider",
+    type: "string",
+    scopes: ["user"],
+    merge: "replace",
+    description: "Push notification provider used to alert the human of chat mentions when away from a terminal.",
+  },
+  {
+    key: "chat.push.target",
+    type: "string",
+    scopes: ["user"],
+    merge: "replace",
+    description: "Destination (topic/URL/token) the configured chat.push.provider sends to.",
+  },
 ];

package/src/settings/write.ts

@@ -160,6 +160,49 @@ export function setSetting(key: string, value: unknown, scope: SettingScope, opt
   );
 }
 
+/**
+ * Removes `key` from the given scope's store, comment-preserving. The refusal
+ * ladder is `setSetting`'s minus the value check (there is no value): unknown
+ * key, unmigrated, scope not in `def.scopes`, repoIdentity on a non-repoScoped
+ * key, and the team-selection rule when ambiguous. Divergences from set, both
+ * because removal has nothing to act on: a store FILE that does not exist is a
+ * clean no-op rather than a refusal (an explicit `opts.team` naming a team
+ * with no local store included — nothing to remove is success, not an error),
+ * and a key not present in the store is a no-op. Returns whether anything was
+ * actually removed; the local-only reminder prints only on a real removal.
+ */
+export function unsetSetting(key: string, scope: SettingScope, opts: SetSettingOpts = {}): boolean {
+  const def = getDef(key);
+  if (!def) {
+    refuse(`unknown setting "${key}" — not in the settings registry (see \`rt settings list\`)`);
+  }
+
+  if (!isMigrated(def)) {
+    refuse(migratedFalseMessage(key, def));
+  }
+
+  if (!def.scopes.includes(scope)) {
+    refuse(`"${key}" cannot be unset in the ${scope} store (allowed: ${def.scopes.join(", ")})`);
+  }
+
+  if (opts.repoIdentity !== undefined && def.repoScoped !== true) {
+    refuse(`"${key}" is not repo-scoped — omit the repo identity`);
+  }
+
+  const storePath = resolveStorePathForUnset(scope, opts);
+  if (storePath === null || !existsSync(storePath)) return false;
+
+  const jsonPath: JSONPath = opts.repoIdentity !== undefined ? ["repos", opts.repoIdentity, key] : [key];
+  const removed = removeFromStore(storePath, jsonPath);
+
+  if (removed) {
+    console.error(
+      `rt: removed "${key}" from the local ${scope} store (${storePath}) — this is local only until you commit and push it.`,
+    );
+  }
+  return removed;
+}
+
 function migratedFalseMessage(key: string, def: SettingDef): string {
   const legacyPart = def.legacyFile ? ` — it is still read from ${def.legacyFile}` : "";
   return `"${key}" is not writable through the settings resolver yet${legacyPart}`;
@@ -188,6 +231,29 @@ function resolveStorePath(scope: SettingScope, opts: SetSettingOpts): string {
   return teamSettingsPath(teams[0] as string);
 }
 
+/**
+ * `resolveStorePath` for removal: same selection rule, but "no store to
+ * target" answers null (nothing to remove) instead of refusing — EXCEPT the
+ * multiple-teams case, which still refuses: guessing which team's store to
+ * edit is banned on the unset side for the same reason as the set side.
+ */
+function resolveStorePathForUnset(scope: SettingScope, opts: SetSettingOpts): string | null {
+  if (scope === "user") return userSettingsPath();
+  if (scope === "machine") return machineSettingsPath();
+
+  if (opts.team !== undefined) {
+    const path = teamSettingsPath(opts.team);
+    return existsSync(path) ? path : null;
+  }
+
+  const teams = listTeams();
+  if (teams.length === 0) return null;
+  if (teams.length > 1) {
+    refuse(`multiple local team stores found (${teams.join(", ")}) — pass opts.team to choose one`);
+  }
+  return teamSettingsPath(teams[0] as string);
+}
+
 /** `// header comment\n{}\n` — see module doc for why the object must be seeded before the first `modify`. */
 function seedHeader(): string {
   return `// rt settings — created by \`rt settings set\`. JSONC: comments and trailing commas are fine.\n{}\n`;
@@ -279,6 +345,31 @@ function writeIntoStore(storePath: string, jsonPath: JSONPath, value: unknown, c
   // a torn write would sit as a corrupt uncommitted file until a human
   // noticed. The edited TEXT is written as-is, never round-tripped through
   // JSON.stringify, so comments and formatting survive.
+  writeTempThenRename(storePath, finalText);
+}
+
+/**
+ * Removes `jsonPath` from an existing store file. A key that isn't present
+ * yields zero edits from `modify` and the file is left untouched (no write,
+ * no mtime churn). Malformed stores refuse exactly as on the set side —
+ * `modify`-by-offset against a duplicate-key document is as wrong for
+ * removal as it is for writes.
+ */
+function removeFromStore(storePath: string, jsonPath: JSONPath): boolean {
+  const content = readFileSync(storePath, "utf8");
+  if (content.trim() === "") return false;
+  assertEditableJsonc(storePath, content);
+
+  const edits = modify(content, jsonPath, undefined, { formattingOptions: FORMAT });
+  if (edits.length === 0) return false;
+
+  const next = applyEdits(content, edits);
+  const finalText = next.endsWith("\n") ? next : `${next}\n`;
+  writeTempThenRename(storePath, finalText);
+  return true;
+}
+
+function writeTempThenRename(storePath: string, finalText: string): void {
   const tmp = `${storePath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
   try {
     writeFileSync(tmp, finalText);