@uniqbit/mate-core 0.15.4 → 0.15.5-canary.1

package/src/tools/setup/plugins/gitignore.ts

@@ -70,6 +70,9 @@ export function collectManagedGitignoreEntries(ctx: SetupContext, plugins: Plugi
   const entries = [
     "node_modules/",
     `.${FRAMEWORK_NAME}/plugins/.local/`,
+    // Holds absolute local paths of every linked working repo; never shared
+    // across machines or committed to the companion repo.
+    `.${FRAMEWORK_NAME}/config/registry.yaml`,
     ".mcp.json*",
     ...plugins
       .filter((p) => p.kind !== "root" && (p.isEnabled(ctx.config) || p.persistGitignoreEntries))

package/src/tools/setup/providers/claude.ts

@@ -16,8 +16,11 @@ import {
   upsertManagedBlock,
 } from "../context-services";
 import type { CapabilityContributionInput, ProviderPlugin, SetupContext } from "../plugin";
-import { resolveGitInfoExcludePath } from "../git-utils";
 import { mergeDir, pruneEmptyAncestors } from "../utils";
+import {
+  ensureWorkingRepoLocalExcludes,
+  reconcileWorkingRepoCapabilityExcludes,
+} from "../working-repo-local-state";
 import {
   cutFromMarker,
   stripSectionFromFile,
@@ -59,13 +62,7 @@ async function configureClaudeGuidance(companionPath: string): Promise<void> {
   );
 }
 
-const BASE_WORKING_REPO_LOCAL_EXCLUDE_ENTRIES = [".claude/settings.local.json"];
-const COMPANION_GITIGNORE_ENTRIES = [...BASE_WORKING_REPO_LOCAL_EXCLUDE_ENTRIES, ".claude/state/"];
-// Union of all managed exclude entries — used to identify which lines we own.
-const ALL_MANAGED_EXCLUDE_ENTRIES = new Set([
-  ...BASE_WORKING_REPO_LOCAL_EXCLUDE_ENTRIES,
-  ...TOKENSAVE_WORKING_REPO_EXCLUDE_ENTRIES,
-]);
+const COMPANION_GITIGNORE_ENTRIES = [".claude/settings.local.json", ".claude/state/"];
 
 // Command substrings that mark a working-repo hook group as Mate-managed.
 // The mate plugin hooks (validate-artifact-path, mate-session-banner,
@@ -151,66 +148,23 @@ function removeManagedHookGroups(
   return next;
 }
 
-export async function ensureWorkingRepoLocalExcludes(
-  workingRepoPath: string,
-  config: FrameworkConfig,
-): Promise<void> {
-  const excludePath = await resolveGitInfoExcludePath(workingRepoPath);
-  if (!excludePath) {
-    return;
-  }
-
-  const tokensaveEnabled = (config.capabilities ?? []).some((c) => c.name === "tokensave");
-  const desiredEntries = new Set([
-    ...BASE_WORKING_REPO_LOCAL_EXCLUDE_ENTRIES,
-    ...(tokensaveEnabled ? TOKENSAVE_WORKING_REPO_EXCLUDE_ENTRIES : []),
-  ]);
-
-  let existing = "";
-  try {
-    existing = await fs.readFile(excludePath, "utf8");
-  } catch {
-    // Fresh repos may not have created info/exclude yet.
-  }
-
-  const lines = existing
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter(Boolean);
-
-  // Reconcile: keep non-managed lines, add desired managed entries, remove undesired.
-  const nextLines = lines.filter((line) => !ALL_MANAGED_EXCLUDE_ENTRIES.has(line));
-  for (const entry of desiredEntries) {
-    if (!nextLines.includes(entry)) {
-      nextLines.push(entry);
-    }
-  }
-
-  const nextContent = nextLines.length > 0 ? nextLines.join("\n") + "\n" : "";
-  if (nextContent === existing) {
-    return;
-  }
-
-  await fs.mkdir(path.dirname(excludePath), { recursive: true });
-  await fs.writeFile(excludePath, nextContent, "utf8");
-}
-
-async function stripTokensaveClaudeMdAppend(workingRepoPath: string): Promise<void> {
+async function stripTokensaveClaudeMdAppend(workingRepoPath: string): Promise<boolean> {
   const claudeMdPath = path.join(workingRepoPath, "CLAUDE.md");
   let content: string;
   try {
     content = await fs.readFile(claudeMdPath, "utf8");
   } catch {
-    return;
+    return false;
   }
 
   const stripped = cutFromMarker(content, TOKENSAVE_CLAUDE_MD_MARKER);
-  if (stripped === content) return;
+  if (stripped === content) return false;
   if (stripped.length > 0) {
     await fs.writeFile(claudeMdPath, stripped, "utf8");
   } else {
     await fs.unlink(claudeMdPath);
   }
+  return true;
 }
 
 // Resolved path of the companion-owned Claude settings document. This is the
@@ -456,7 +410,15 @@ export async function syncWorkingRepoClaudeSettings(
   config: FrameworkConfig,
   globalConfigStore = new GlobalConfigStore(),
 ): Promise<void> {
-  await ensureWorkingRepoLocalExcludes(workingRepoPath, config);
+  await ensureWorkingRepoLocalExcludes(workingRepoPath);
+  const tokensaveEnabled = (config.capabilities ?? []).some(
+    (capability) => capability.name === "tokensave",
+  );
+  await reconcileWorkingRepoCapabilityExcludes(
+    workingRepoPath,
+    tokensaveEnabled ? TOKENSAVE_WORKING_REPO_EXCLUDE_ENTRIES : [],
+    TOKENSAVE_WORKING_REPO_EXCLUDE_ENTRIES,
+  );
   await syncWorkingRepoClaudeAdditionalDirectories(
     workingRepoPath,
     companionPath,
@@ -507,6 +469,56 @@ async function syncWorkingRepoClaudeAdditionalDirectories(
   await writeClaudeSettings(settingsPath, settings);
 }
 
+export async function cleanupWorkingRepoClaudeSettings(
+  workingRepoPath: string,
+  registeredCompanionPaths: string[],
+): Promise<boolean> {
+  const settingsPath = path.join(workingRepoPath, ".claude", "settings.local.json");
+  let existing: ClaudeSettings;
+  try {
+    const parsed = JSON.parse(await fs.readFile(settingsPath, "utf8")) as unknown;
+    if (!parsed || typeof parsed !== "object") return stripTokensaveClaudeMdAppend(workingRepoPath);
+    existing = parsed as ClaudeSettings;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return stripTokensaveClaudeMdAppend(workingRepoPath);
+    }
+    return false;
+  }
+
+  const settings = removeManagedHookGroups(existing);
+  const permissions = { ...settings.permissions };
+  const managedPaths = new Set(
+    registeredCompanionPaths.map((candidate) => path.resolve(candidate)),
+  );
+  const currentDirectories = Array.isArray(permissions.additionalDirectories)
+    ? permissions.additionalDirectories
+    : [];
+  const additionalDirectories = currentDirectories.filter(
+    (candidate) => !managedPaths.has(path.resolve(candidate)),
+  );
+  if (additionalDirectories.length > 0) {
+    permissions.additionalDirectories = additionalDirectories;
+  } else {
+    delete permissions.additionalDirectories;
+  }
+  if (Object.keys(permissions).length > 0) {
+    settings.permissions = permissions;
+  } else {
+    delete settings.permissions;
+  }
+
+  const settingsChanged = JSON.stringify(settings) !== JSON.stringify(existing);
+  if (settingsChanged && Object.keys(settings).length === 0) {
+    await fs.unlink(settingsPath);
+    await pruneEmptyAncestors(path.join(workingRepoPath, ".claude"), workingRepoPath);
+  } else if (settingsChanged) {
+    await writeClaudeSettings(settingsPath, settings);
+  }
+  const guidanceChanged = await stripTokensaveClaudeMdAppend(workingRepoPath);
+  return settingsChanged || guidanceChanged;
+}
+
 async function configureClaude(companionPath: string): Promise<void> {
   // Mate hooks are delivered by the bundled Claude plugin at launch; nothing
   // is copied into `companion/.claude/hooks/` anymore. Stale copies from

package/src/tools/setup/working-repo-cleanup.ts

@@ -0,0 +1,40 @@
+import fs from "node:fs/promises";
+
+import { repoLocalDirPath } from "../../lib/orchestrator/repo-local-registry";
+import { cleanupWorkingRepoClaudeSettings } from "./providers/claude";
+import { removeWorkingRepoLocalExcludes } from "./working-repo-local-state";
+
+export interface WorkingRepoCleanupResult {
+  changed: boolean;
+  removed: string[];
+  updated: string[];
+}
+
+async function pathExists(candidatePath: string): Promise<boolean> {
+  try {
+    await fs.access(candidatePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function cleanupWorkingRepository(
+  repoPath: string,
+  registeredCompanionPaths: string[],
+): Promise<WorkingRepoCleanupResult> {
+  const updated: string[] = [];
+  const removed: string[] = [];
+  if (await cleanupWorkingRepoClaudeSettings(repoPath, registeredCompanionPaths)) {
+    updated.push("claude-settings");
+  }
+  if (await removeWorkingRepoLocalExcludes(repoPath)) {
+    removed.push("git-excludes");
+  }
+  const localDir = repoLocalDirPath(repoPath);
+  if (await pathExists(localDir)) {
+    await fs.rm(localDir, { recursive: true, force: true });
+    removed.unshift(".mate");
+  }
+  return { changed: removed.length > 0 || updated.length > 0, removed, updated };
+}

package/src/tools/setup/working-repo-local-state.ts

@@ -0,0 +1,103 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { resolveGitInfoExcludePath } from "./git-utils";
+
+const MANAGED_BLOCK_START = "# mate managed: start";
+const MANAGED_BLOCK_END = "# mate managed: end";
+const CORE_EXCLUDE_ENTRIES = ["/.mate/", "/.claude/", "/.opencode/", "/.agents/"];
+const LEGACY_CORE_EXCLUDE_ENTRIES = new Set([".mate/", ".claude/settings.local.json"]);
+
+async function readExclude(excludePath: string): Promise<string> {
+  try {
+    return await fs.readFile(excludePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function contentLines(content: string): string[] {
+  const lines = content.split(/\r?\n/);
+  if (lines.at(-1) === "") lines.pop();
+  return lines;
+}
+
+function withoutManagedBlocks(lines: string[]): string[] {
+  const next: string[] = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index].trim() !== MANAGED_BLOCK_START) {
+      next.push(lines[index]);
+      continue;
+    }
+    const end = lines.findIndex(
+      (line, candidateIndex) => candidateIndex > index && line.trim() === MANAGED_BLOCK_END,
+    );
+    if (end === -1) {
+      next.push(lines[index]);
+      continue;
+    }
+    index = end;
+  }
+  return next;
+}
+
+function trimTrailingEmptyLines(lines: string[]): string[] {
+  const next = [...lines];
+  while (next.at(-1)?.trim() === "") next.pop();
+  return next;
+}
+
+async function writeExclude(
+  excludePath: string,
+  existing: string,
+  lines: string[],
+): Promise<boolean> {
+  const nextContent = lines.length > 0 ? `${lines.join("\n")}\n` : "";
+  if (nextContent === existing) return false;
+  await fs.mkdir(path.dirname(excludePath), { recursive: true });
+  await fs.writeFile(excludePath, nextContent, "utf8");
+  return true;
+}
+
+export async function ensureWorkingRepoLocalExcludes(repoPath: string): Promise<boolean> {
+  const excludePath = await resolveGitInfoExcludePath(repoPath);
+  if (!excludePath) return false;
+  const existing = await readExclude(excludePath);
+  const lines = trimTrailingEmptyLines(
+    withoutManagedBlocks(contentLines(existing)).filter(
+      (line) => !LEGACY_CORE_EXCLUDE_ENTRIES.has(line.trim()),
+    ),
+  );
+  lines.push(MANAGED_BLOCK_START, ...CORE_EXCLUDE_ENTRIES, MANAGED_BLOCK_END);
+  return writeExclude(excludePath, existing, lines);
+}
+
+export async function reconcileWorkingRepoCapabilityExcludes(
+  repoPath: string,
+  desiredEntries: string[],
+  managedEntries: string[],
+): Promise<boolean> {
+  const excludePath = await resolveGitInfoExcludePath(repoPath);
+  if (!excludePath) return false;
+  const existing = await readExclude(excludePath);
+  const managed = new Set(managedEntries);
+  const lines = trimTrailingEmptyLines(
+    contentLines(existing).filter((line) => !managed.has(line.trim())),
+  );
+  for (const entry of desiredEntries) {
+    if (!lines.some((line) => line.trim() === entry)) lines.push(entry);
+  }
+  return writeExclude(excludePath, existing, lines);
+}
+
+export async function removeWorkingRepoLocalExcludes(repoPath: string): Promise<boolean> {
+  const excludePath = await resolveGitInfoExcludePath(repoPath);
+  if (!excludePath) return false;
+  const existing = await readExclude(excludePath);
+  const lines = trimTrailingEmptyLines(
+    withoutManagedBlocks(contentLines(existing)).filter(
+      (line) => !LEGACY_CORE_EXCLUDE_ENTRIES.has(line.trim()),
+    ),
+  );
+  return writeExclude(excludePath, existing, lines);
+}