@uniqbit/mate-core 0.15.4-canary.8 → 0.15.4

package/src/tools/setup/capabilities/context-mode.ts

@@ -1,4 +1,3 @@
-// oxlint-disable no-await-in-loop -- config files are reconciled sequentially with shared ownership state
 import fs from "node:fs/promises";
 import path from "node:path";
 
@@ -11,18 +10,21 @@ import {
   validateContextModePackage,
 } from "../../../lib/context-mode-package";
 import { warmOpenCodePackageCache } from "../../../lib/opencode-plugin-package";
-import type { CapabilityPlugin, LaunchPreflightContext, SetupContext } from "../plugin";
+import type {
+  CapabilityPlugin,
+  LaunchPreflightContext,
+  RuntimeContributionsByRuntime,
+  SetupContext,
+} from "../plugin";
+import { readClaudeMcpConfig } from "../providers/claude-format";
+import { getOpenCodePluginReferences, readOpenCodeConfig } from "../providers/opencode-format";
 import { pruneEmptyAncestors } from "../utils";
 
-type Config = Record<string, unknown>;
 interface ContextModePluginDeps {
   installPackage?: typeof installContextModePackage;
   validatePackage?: typeof validateContextModePackage;
   warmOpenCodePackage?: typeof warmOpenCodePackageCache;
 }
-interface OwnershipState {
-  opencodeConfigs: string[];
-}
 
 export const CONTEXT_MODE_OPENCODE_GUIDANCE = `## Context Mode
 
@@ -30,47 +32,19 @@ Use Context Mode tools for commands or tool calls whose output may be large, for
 
 Canonical Mate policy and any more specific tool-routing instructions remain authoritative. In particular, follow explicit requirements to use TokenSave for codebase exploration, Context7 for library documentation, and specialized tools for their assigned operations; Context Mode complements rather than replaces them.`;
 
-function getOwnershipPath(companionPath: string): string {
+// Legacy ownership sidecar from before the managed-marker scheme; removed on
+// sight (managed identity is `isContextModePackageReference` now).
+function getLegacyOwnershipPath(companionPath: string): string {
   return path.join(companionPath, ".mate", "state", "context-mode.json");
 }
 
-async function readOwnership(companionPath: string): Promise<OwnershipState> {
-  try {
-    return JSON.parse(await fs.readFile(getOwnershipPath(companionPath), "utf8")) as OwnershipState;
-  } catch {
-    return { opencodeConfigs: [] };
-  }
-}
-
-async function writeOwnership(companionPath: string, state: OwnershipState): Promise<void> {
-  const statePath = getOwnershipPath(companionPath);
-  if (state.opencodeConfigs.length === 0) {
-    await fs.rm(statePath, { force: true });
-    return;
-  }
-  await fs.mkdir(path.dirname(statePath), { recursive: true });
-  await fs.writeFile(statePath, JSON.stringify(state, null, 2) + "\n", "utf8");
-}
-
-function isRecord(value: unknown): value is Config {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+// Legacy install location from before the relocate-distribution-deps-to-plugins-local
+// change; self-heals on every apply the same way the ownership sidecar above does.
+function getLegacyInstallDir(companionPath: string): string {
+  return path.join(companionPath, ".mate", "dependencies", CONTEXT_MODE_PACKAGE_NAME);
 }
 
-async function readConfig(filePath: string): Promise<Config> {
-  try {
-    const parsed = JSON.parse(await fs.readFile(filePath, "utf8")) as unknown;
-    return isRecord(parsed) ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-
-function hasContextModeMcp(config: Config): boolean {
-  const servers = isRecord(config.mcpServers)
-    ? config.mcpServers
-    : isRecord(config.mcp)
-      ? config.mcp
-      : {};
+function hasContextModeMcp(servers: Record<string, unknown>): boolean {
   return Object.entries(servers).some(
     ([name, value]) =>
       name.toLowerCase().includes("context-mode") || JSON.stringify(value).includes("context-mode"),
@@ -78,58 +52,30 @@ function hasContextModeMcp(config: Config): boolean {
 }
 
 async function assertNoMcpConflict(ctx: SetupContext, provider: "claude" | "opencode") {
+  const servers =
+    provider === "claude"
+      ? ((await readClaudeMcpConfig(path.join(ctx.companionPath, ".mcp.json"))).config.mcpServers ??
+        {})
+      : (((await readOpenCodeConfig(path.join(ctx.companionPath, ".opencode", "opencode.json")))
+          .config.mcp as Record<string, unknown>) ?? {});
   const configPath =
     provider === "claude"
       ? path.join(ctx.companionPath, ".mcp.json")
       : path.join(ctx.companionPath, ".opencode", "opencode.json");
-  if (hasContextModeMcp(await readConfig(configPath))) {
+  if (hasContextModeMcp(servers)) {
     throw new Error(
       `Cannot enable context-mode for ${provider}: ${configPath} already contains a context-mode MCP registration. Remove the duplicate registration or deselect the context-mode capability; Mate did not modify it.`,
     );
   }
 }
 
-async function updateOpenCodeConfig(ctx: SetupContext, enabled: boolean): Promise<void> {
-  const reference = getContextModePackageReference();
-  const ownership = await readOwnership(ctx.companionPath);
-  for (const name of ["opencode.json", "tui.json"]) {
-    const configPath = path.join(ctx.companionPath, ".opencode", name);
-    const owned = ownership.opencodeConfigs.includes(name);
-    if (!enabled && !owned) continue;
-    const config = await readConfig(configPath);
-    const plugins = Array.isArray(config.plugin) ? config.plugin : [];
-    const contextModeReferences = plugins.filter(isContextModePackageReference);
-    if (enabled && contextModeReferences.some((entry) => entry !== reference)) {
-      throw new Error(
-        `Cannot enable ${reference}: ${configPath} contains user-owned context-mode reference ${contextModeReferences.join(", ")}. Mate did not modify it.`,
-      );
-    }
-    const preserved = plugins.filter((entry) => !(entry === reference && owned));
-    if (enabled) {
-      if (!contextModeReferences.includes(reference)) {
-        config.plugin = [...plugins, reference];
-        ownership.opencodeConfigs.push(name);
-      }
-    } else if (preserved.length > 0) {
-      config.plugin = preserved;
-    } else {
-      delete config.plugin;
-    }
-    await fs.mkdir(path.dirname(configPath), { recursive: true });
-    await fs.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
-  }
-  if (!enabled) ownership.opencodeConfigs = [];
-  await writeOwnership(ctx.companionPath, ownership);
-}
-
 async function validateOpenCodeReferences(ctx: LaunchPreflightContext): Promise<string[]> {
   const expected = getContextModePackageReference();
   const diagnostics: string[] = [];
   for (const name of ["opencode.json", "tui.json"]) {
     const configPath = path.join(ctx.companionPath, ".opencode", name);
-    const config = await readConfig(configPath);
-    const plugins = Array.isArray(config.plugin) ? config.plugin : [];
-    if (!plugins.includes(expected)) {
+    const { config } = await readOpenCodeConfig(configPath);
+    if (!getOpenCodePluginReferences(config).includes(expected)) {
       diagnostics.push(
         `Missing or stale context-mode package reference in ${configPath}; expected ${expected}.`,
       );
@@ -150,7 +96,36 @@ export function createContextModePlugin(deps: ContextModePluginDeps = {}): Capab
     defaultSelected: false,
     isEnabled: (config) =>
       (config.capabilities ?? []).some((capability) => capability.name === "context-mode"),
+    // The pinned OpenCode plugin reference is declared and reconciled by the
+    // OpenCode Runtime Surface into both config files. Any context-mode
+    // reference counts as Mate-managed (marker scheme), so stale pins are
+    // replaced and teardown removes only context-mode entries.
+    getRuntimeContributions(): RuntimeContributionsByRuntime {
+      return {
+        claude: {
+          // The context-mode Claude plugin exposes its skill and MCP tools
+          // under the plugin namespace; pre-seed both so routine routing
+          // doesn't prompt.
+          permissionEntries: [
+            "Skill(context-mode:context-mode)",
+            "mcp__plugin_context-mode_context-mode__*",
+          ],
+        },
+        opencode: {
+          pluginReferences: [
+            {
+              reference: getContextModePackageReference(),
+              isManagedReference: isContextModePackageReference,
+              configFiles: ["opencode.json", "tui.json"],
+            },
+          ],
+        },
+      };
+    },
     async apply(ctx) {
+      const legacyInstallDir = getLegacyInstallDir(ctx.companionPath);
+      await fs.rm(legacyInstallDir, { recursive: true, force: true });
+      await pruneEmptyAncestors(path.dirname(legacyInstallDir), ctx.companionPath);
       if (ctx.mode === "setup") {
         await installPackage(ctx.companionPath);
       } else {
@@ -159,10 +134,12 @@ export function createContextModePlugin(deps: ContextModePluginDeps = {}): Capab
       await ctx.instructions?.append(CONTEXT_MODE_OPENCODE_GUIDANCE, {
         providers: ["opencode"],
       });
+      await fs.rm(getLegacyOwnershipPath(ctx.companionPath), { force: true });
     },
     async teardown(ctx) {
       await fs.rm(getContextModeInstallDir(ctx.companionPath), { recursive: true, force: true });
       await pruneEmptyAncestors(getContextModeInstallDir(ctx.companionPath), ctx.companionPath);
+      await fs.rm(getLegacyOwnershipPath(ctx.companionPath), { force: true });
     },
     forProvider: {
       claude: {
@@ -175,7 +152,6 @@ export function createContextModePlugin(deps: ContextModePluginDeps = {}): Capab
         preflight: validateOpenCodeReferences,
         async apply(ctx) {
           await assertNoMcpConflict(ctx, "opencode");
-          await updateOpenCodeConfig(ctx, true);
           if (ctx.mode === "setup") {
             const result = await warmOpenCodePackage(
               CONTEXT_MODE_PACKAGE_NAME,
@@ -188,9 +164,7 @@ export function createContextModePlugin(deps: ContextModePluginDeps = {}): Capab
             }
           }
         },
-        async teardown(ctx) {
-          await updateOpenCodeConfig(ctx, false);
-        },
+        async teardown() {},
       },
     },
   };

package/src/tools/setup/capabilities/graphify-shared.ts

@@ -0,0 +1,27 @@
+import { FRAMEWORK_NAME } from "../../../framework";
+import {
+  removeHeadingSection,
+  type RemoveHeadingSectionOptions,
+} from "../providers/agent-file-sections";
+
+// Identity of the agent-file section `graphify install` writes. Declared in a
+// leaf module (capability-owned) so both the graphify capability and the
+// guidance plugin can consume it without an import cycle.
+
+// Marker names derive from the framework identity, never the invocation name.
+export const GRAPHIFY_START = () => `<!-- ${FRAMEWORK_NAME.toUpperCase()}:GRAPHIFY:START -->`;
+export const GRAPHIFY_END = () => `<!-- ${FRAMEWORK_NAME.toUpperCase()}:GRAPHIFY:END -->`;
+
+export function isGraphifyHeading(line: string): boolean {
+  return /^#{1,6}\s+graphify\s*$/i.test(line);
+}
+
+/** Section identity passed to the Runtime Surface escape hatch. */
+export function graphifySectionOptions(): RemoveHeadingSectionOptions {
+  return { isHeading: isGraphifyHeading, markerLines: [GRAPHIFY_START(), GRAPHIFY_END()] };
+}
+
+// Removes the graphify section from content, collapsing leftover blank lines.
+export function removeGraphifySection(content: string): string {
+  return removeHeadingSection(content, graphifySectionOptions());
+}