@uniqbit/mate-core 0.15.4-canary.3 → 0.15.4-canary.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniqbit/mate-core",
-  "version": "0.15.4-canary.3",
+  "version": "0.15.4-canary.6",
   "description": "Core framework and plugin APIs for Mate.",
   "license": "MIT",
   "files": [

package/src/cli/commands/artifact/finish/openspec.ts

@@ -61,10 +61,7 @@ async function capSync(context: FinishContext): Promise<boolean> {
   const previous = process.exitCode;
   process.exitCode = 0;
   const previousEnv = new Map(
-    ["MATE_ARTIFACT_PATH", "MATE_REPO_PATH", "MATE_REPO_ID", "MATE_REPO_PROFILE"].map((key) => [
-      key,
-      process.env[key],
-    ]),
+    ["MATE_ARTIFACT_PATH", "MATE_REPO_PATH", "MATE_REPO_ID"].map((key) => [key, process.env[key]]),
   );
 
   // Pass both sides of the companion/working-repo boundary explicitly. Capability
@@ -73,7 +70,6 @@ async function capSync(context: FinishContext): Promise<boolean> {
   if (context.repository) {
     process.env.MATE_REPO_PATH = context.repository.path;
     process.env.MATE_REPO_ID = context.repository.id;
-    process.env.MATE_REPO_PROFILE = context.repository.profile;
   }
   try {
     await runIndexCapCommand([]);

package/src/cli/commands/companion/link.ts

@@ -10,7 +10,6 @@ import {
   type CompanionLinkWizardOptions,
 } from "../../companion-link-wizard";
 import { extractRepoName } from "../artifact/extract-repo-name";
-import { defaultConfig } from "../../../lib/orchestrator/config-store";
 import { GlobalConfigStore } from "../../../lib/orchestrator/global-config-store";
 import { CompanionResolver } from "../../../lib/orchestrator/companion-resolver";
 import { inspectSetupPreflight } from "../../../lib/orchestrator/setup-preflight";
@@ -131,7 +130,6 @@ export async function runCompanionLinkCommandWithDeps(
 
   const cwd = path.resolve(process.cwd());
   const existingMatch = await resolveCompanion(cwd);
-  const profiles = Object.keys(defaultConfig().profiles);
   const companionsDir = companionsHomeDir();
   const candidatePaths = new Set(await listCompanions());
   if (existingMatch) candidatePaths.add(existingMatch.companionPath);
@@ -148,7 +146,6 @@ export async function runCompanionLinkCommandWithDeps(
   ).filter((candidate): candidate is string => candidate !== null);
 
   const inputs = await selectInputs({
-    profiles,
     existingCompanions,
   });
   if (!inputs) {
@@ -241,7 +238,6 @@ export async function runCompanionLinkCommandWithDeps(
   const repository: LinkedRepository = {
     id: path.basename(cwd),
     path: cwd,
-    profile: inputs.profile,
   };
 
   const registerRepository =
@@ -292,6 +288,5 @@ export async function runCompanionLinkCommandWithDeps(
     console.log(`  Companion: ${companionPath}`);
   }
   console.log(`  Source: ${persistedSource}`);
-  console.log(`  Profile: ${repository.profile}`);
   console.log("  Workspace: run `mate companion open` to open the workspace in your editor");
 }

package/src/cli/commands/companion/tui.ts

@@ -81,7 +81,6 @@ export async function runCompanionTuiCommand(): Promise<void> {
   if (repository) {
     process.env.MATE_REPO_PATH = repository.path;
     process.env.MATE_REPO_ID = repository.id;
-    process.env.MATE_REPO_PROFILE = repository.profile;
   }
 
   console.log(renderBanner(repoPath, companionPath));

package/src/cli/commands/doctor.ts

@@ -1,16 +1,13 @@
-import fs from "node:fs/promises";
+import { execFileSync } from "node:child_process";
 import path from "node:path";
 
 import { FRAMEWORK_NAME } from "../../framework";
 import { getActiveDistribution } from "../../distribution";
-import { CompanionResolver } from "../../lib/orchestrator/companion-resolver";
-import { CompanionStore, resolvePolicyFromConfig } from "../../lib/orchestrator/companion-store";
-import { ConfigStore } from "../../lib/orchestrator/config-store";
 import { checkEngineRequirement } from "../../lib/orchestrator/engine-guard";
-import { GlobalConfigStore } from "../../lib/orchestrator/global-config-store";
-import { findRepoLocalLinkedRepository } from "../../lib/orchestrator/repo-local-registry";
-import type { CapabilityConfig, FrameworkConfig } from "../../lib/orchestrator/types";
-import { WorkingRepoStore } from "../../lib/orchestrator/working-repo-store";
+import type { GlobalConfigStore } from "../../lib/orchestrator/global-config-store";
+import { pathIsDirectory } from "../../lib/orchestrator/repo-local-registry";
+import { resolveRootContext, type RootContext } from "../../lib/orchestrator/root-context";
+import type { CapabilityConfig, FrameworkConfig, HubMember } from "../../lib/orchestrator/types";
 import { getRequiredPluginDrift } from "../../tools/setup/policy";
 import { resolveCommandOnPath } from "../../tools/setup/utils";
 import { printSection, renderKeyValueTable, renderTable } from "./status";
@@ -19,11 +16,43 @@ interface DoctorDeps {
   globalConfigStore?: GlobalConfigStore;
   cwd?: string;
   pathValue?: string;
+  /** Returns a member checkout's HEAD commit, or null when unreadable. */
+  gitHead?: (memberPath: string) => string | null;
 }
 
-interface CompanionStores {
-  configStore: ConfigStore;
-  workingRepoStore: WorkingRepoStore;
+export type DoctorKind = "core" | "working" | "companion" | "hub";
+
+export interface DoctorToolInstallation {
+  tool: string;
+  source: string;
+  status: "ok" | "missing";
+  path: string | null;
+}
+
+export interface DoctorHubMember {
+  id: string;
+  source: "git" | "local";
+  path: string;
+  exists: boolean;
+  commitStatus: "ok" | "drifted" | "missing" | "unknown";
+  materializedCommit: string | null;
+  actualCommit: string | null;
+}
+
+export interface DoctorReport {
+  kind: DoctorKind;
+  cwd: string;
+  companionPath: string | null;
+  repositoryId: string | null;
+  multipleCompanions: Array<{ companionPath: string; repositoryId: string }>;
+  policy?: { allowedAgents: string[] };
+  policyError?: string;
+  capabilities?: string[];
+  toolInstallations?: DoctorToolInstallation[];
+  requiredPluginDrift?: Array<{ pluginId: string; kind: string; reason: string }>;
+  engineRequirement?: { range: string; ok: boolean; detail: string };
+  hub?: { members: DoctorHubMember[] };
+  resolutionFailures: Array<{ companionPath: string; message: string }>;
 }
 
 interface ToolCheck {
@@ -32,75 +61,26 @@ interface ToolCheck {
   source: string;
 }
 
-function storesForCompanion(companionPath: string): CompanionStores {
-  const configDir = path.join(companionPath, `.${FRAMEWORK_NAME}`, "config");
-  return {
-    configStore: new ConfigStore(path.join(configDir, "framework.yaml")),
-    workingRepoStore: new WorkingRepoStore(path.join(configDir, "registry.yaml")),
-  };
+/** Doctor's view of the shared root kind: registry/env resolution means cwd is a working repo. */
+function doctorKind(root: RootContext): DoctorKind {
+  if (root.kind === "core") return "core";
+  if (root.kind === "hub") return "hub";
+  if (root.origin === "env" || root.origin === "registry") return "working";
+  return root.kind;
 }
 
-async function hasLocalCompanionConfig(cwd: string): Promise<boolean> {
-  const localDir = path.join(cwd, `.${FRAMEWORK_NAME}`);
-
+function defaultGitHead(memberPath: string): string | null {
   try {
-    await fs.access(path.join(localDir, "config", "framework.yaml"));
-    return true;
+    return execFileSync("git", ["-C", memberPath, "rev-parse", "HEAD"], {
+      stdio: ["ignore", "pipe", "ignore"],
+    })
+      .toString()
+      .trim();
   } catch {
-    return false;
+    return null;
   }
 }
 
-function renderList(items: string[], empty: string): string {
-  return items.length > 0 ? items.map((item) => `- ${item}`).join("\n") : empty;
-}
-
-function renderEngineRequirement(
-  config: FrameworkConfig,
-  distributionName: string,
-  currentVersion: string,
-): string {
-  const range = config.engines?.[distributionName];
-  const result = checkEngineRequirement(config, distributionName, currentVersion);
-  return result.ok
-    ? `engines.${distributionName}: satisfied (requires ${range}, running ${currentVersion})`
-    : `engines.${distributionName}: ${result.reason}`;
-}
-
-// Only the engines key matching the running distribution produces a
-// diagnostic; foreign distribution keys are ignored entirely.
-function printEngineRequirement(config: FrameworkConfig): void {
-  const distribution = getActiveDistribution().config;
-  if (!config.engines?.[FRAMEWORK_NAME]) return;
-  printSection(
-    "Version Requirement",
-    renderEngineRequirement(config, FRAMEWORK_NAME, distribution.version),
-  );
-}
-
-// Companions with no drift produce no section at all: required plugins are
-// silent when healthy.
-function printRequiredPluginDrift(config: FrameworkConfig): void {
-  const drift = getRequiredPluginDrift(config);
-  if (drift.length === 0) return;
-  printSection(
-    "Required Plugin Drift",
-    renderTable(
-      ["Plugin", "Kind", "Issue"],
-      drift.map((entry) => [entry.pluginId, entry.kind, entry.reason]),
-    ),
-  );
-}
-
-function renderCapabilities(capabilities: CapabilityConfig[]): string {
-  return capabilities.length > 0
-    ? renderTable(
-        ["Capability"],
-        capabilities.map((capability) => [capability.name]),
-      )
-    : "No capabilities configured.";
-}
-
 function getSelectedToolChecks(config: {
   capabilities?: CapabilityConfig[];
   packageManagers?: string[];
@@ -136,76 +116,183 @@ function getSelectedToolChecks(config: {
   return checks;
 }
 
-function renderToolInstallations(
-  config: {
-    capabilities?: CapabilityConfig[];
-    packageManagers?: string[];
-  },
+function collectToolInstallations(
+  config: FrameworkConfig,
   pathValue: string,
-): string {
-  const checks = getSelectedToolChecks(config);
-  if (checks.length === 0) {
-    return "No selected capabilities or package managers require command checks.";
+): DoctorToolInstallation[] {
+  return getSelectedToolChecks(config).map((check) => {
+    const resolved = resolveCommandOnPath(check.command, pathValue);
+    return {
+      tool: check.name,
+      source: check.source,
+      status: resolved ? "ok" : "missing",
+      path: resolved ?? null,
+    };
+  });
+}
+
+// Only the engines key matching the running distribution produces a
+// diagnostic; foreign distribution keys are ignored entirely.
+function collectEngineRequirement(
+  config: FrameworkConfig,
+): DoctorReport["engineRequirement"] | undefined {
+  const range = config.engines?.[FRAMEWORK_NAME];
+  if (!range) return undefined;
+  const currentVersion = getActiveDistribution().config.version;
+  const result = checkEngineRequirement(config, FRAMEWORK_NAME, currentVersion);
+  return {
+    range,
+    ok: result.ok,
+    detail: result.ok
+      ? `engines.${FRAMEWORK_NAME}: satisfied (requires ${range}, running ${currentVersion})`
+      : `engines.${FRAMEWORK_NAME}: ${result.reason}`,
+  };
+}
+
+async function collectHubMember(
+  hubPath: string,
+  member: HubMember,
+  gitHead: (memberPath: string) => string | null,
+): Promise<DoctorHubMember> {
+  const memberPath = path.resolve(hubPath, member.path);
+  const base = {
+    id: member.id,
+    source: member.source.kind,
+    path: memberPath,
+    materializedCommit: member.materializedCommit ?? null,
+  };
+  if (!(await pathIsDirectory(memberPath))) {
+    return { ...base, exists: false, commitStatus: "missing", actualCommit: null };
+  }
+  if (!member.materializedCommit) {
+    return { ...base, exists: true, commitStatus: "ok", actualCommit: null };
   }
+  const actualCommit = gitHead(memberPath);
+  return {
+    ...base,
+    exists: true,
+    commitStatus:
+      actualCommit === null
+        ? "unknown"
+        : actualCommit === member.materializedCommit
+          ? "ok"
+          : "drifted",
+    actualCommit,
+  };
+}
 
-  return renderTable(
-    ["Tool", "Source", "Status", "Path"],
-    checks.map((check) => {
-      const resolved = resolveCommandOnPath(check.command, pathValue);
-      return [check.name, check.source, resolved ? "ok" : "missing", resolved ?? ""];
-    }),
-  );
+async function collectWorkingSections(
+  report: DoctorReport,
+  root: RootContext,
+  pathValue: string,
+): Promise<void> {
+  if (!root.rootPath || !root.repositoryId || !root.config) {
+    report.policyError = "No repository ID was provided for the resolved companion.";
+    return;
+  }
+
+  report.policy = { allowedAgents: root.config.allowedAgents ?? [] };
+  collectConfiguredRootSections(report, root.config, pathValue);
 }
 
-/**
- * @command mate doctor
- * @description Reports whether the current directory resolves as a linked
- * working repository, a companion repository, or neither. For linked working
- * repositories it also prints the effective policy and enabled capabilities.
- */
-export async function runDoctorCommand(_argv: string[] = [], deps: DoctorDeps = {}): Promise<void> {
-  const cwd = deps.cwd ?? process.cwd();
+function collectConfiguredRootSections(
+  report: DoctorReport,
+  config: FrameworkConfig,
+  pathValue: string,
+): void {
+  report.capabilities = (config.capabilities ?? []).map((capability) => capability.name);
+  report.toolInstallations = collectToolInstallations(config, pathValue);
+  report.requiredPluginDrift = getRequiredPluginDrift(config);
+  report.engineRequirement = collectEngineRequirement(config);
+}
+
+export async function collectDoctorReport(deps: DoctorDeps = {}): Promise<DoctorReport> {
+  const cwd = path.resolve(deps.cwd ?? process.cwd());
   const pathValue = deps.pathValue ?? process.env.PATH ?? "";
-  const envCompanionPath = process.env.MATE_ARTIFACT_PATH;
-  const globalConfigStore = deps.globalConfigStore ?? new GlobalConfigStore();
-  const resolver = new CompanionResolver(globalConfigStore);
+  const gitHead = deps.gitHead ?? defaultGitHead;
+  const root = await resolveRootContext(cwd, deps);
+  const kind = doctorKind(root);
 
-  let state: "linked-working-repository" | "companion-repository" | "not-linked";
-  let companionPath = "";
-  let repositoryId = "";
-  let repository = await findRepoLocalLinkedRepository(cwd);
-  const resolution = envCompanionPath
-    ? { match: null, failures: [], ambiguousMatches: [] }
-    : await resolver.resolveWithDiagnostics(cwd);
+  const report: DoctorReport = {
+    kind,
+    cwd,
+    companionPath: root.rootPath ?? null,
+    repositoryId: root.repositoryId ?? null,
+    multipleCompanions:
+      root.resolution.ambiguousMatches.length > 1 ? root.resolution.ambiguousMatches : [],
+    resolutionFailures: root.resolution.failures,
+  };
 
-  if (envCompanionPath) {
-    state = "linked-working-repository";
-    companionPath = path.resolve(envCompanionPath);
-    repositoryId = process.env.MATE_REPO_ID ?? repository?.id ?? "";
-  } else if (resolution.match) {
-    state = "linked-working-repository";
-    companionPath = resolution.match.companionPath;
-    repositoryId = repository?.id ?? resolution.match.repositoryId;
-  } else if (await hasLocalCompanionConfig(cwd)) {
-    state = "companion-repository";
-    companionPath = cwd;
-  } else {
-    state = "not-linked";
+  if (kind === "working") {
+    await collectWorkingSections(report, root, pathValue);
+  } else if (kind === "companion" && root.config) {
+    collectConfiguredRootSections(report, root.config, pathValue);
+  } else if (kind === "hub" && root.rootPath && root.config) {
+    report.hub = {
+      members: await Promise.all(
+        (root.config.hub?.companions ?? []).map((member) =>
+          collectHubMember(root.rootPath!, member, gitHead),
+        ),
+      ),
+    };
+    report.requiredPluginDrift = getRequiredPluginDrift(root.config);
+    report.engineRequirement = collectEngineRequirement(root.config);
   }
 
+  return report;
+}
+
+function renderList(items: string[], empty: string): string {
+  return items.length > 0 ? items.map((item) => `- ${item}`).join("\n") : empty;
+}
+
+function renderCapabilities(capabilities: string[]): string {
+  return capabilities.length > 0
+    ? renderTable(
+        ["Capability"],
+        capabilities.map((capability) => [capability]),
+      )
+    : "No capabilities configured.";
+}
+
+function renderToolInstallations(installations: DoctorToolInstallation[]): string {
+  if (installations.length === 0) {
+    return "No selected capabilities or package managers require command checks.";
+  }
+  return renderTable(
+    ["Tool", "Source", "Status", "Path"],
+    installations.map((item) => [item.tool, item.source, item.status, item.path ?? ""]),
+  );
+}
+
+function renderHubMembers(members: DoctorHubMember[]): string {
+  if (members.length === 0) return "No hub members configured.";
+  return renderTable(
+    ["Member", "Source", "Path", "Exists", "Commit"],
+    members.map((member) => [
+      member.id,
+      member.source,
+      member.path,
+      member.exists ? "yes" : "no",
+      member.commitStatus,
+    ]),
+  );
+}
+
+function renderHumanReport(report: DoctorReport): void {
   console.log("Mate Doctor");
   console.log("");
   printSection(
     "Context",
     renderKeyValueTable([
-      ["State", state],
-      ["Current Working Directory", cwd],
-      ["Companion Path", companionPath || "none"],
-      ["Repository ID", repositoryId || "none"],
+      ["State", report.kind],
+      ["Current Working Directory", report.cwd],
+      ["Companion Path", report.companionPath ?? "none"],
+      ["Repository ID", report.repositoryId ?? "none"],
     ]),
   );
 
-  if (resolution.ambiguousMatches.length > 1) {
+  if (report.multipleCompanions.length > 1) {
     printSection(
       "Multiple Companions",
       [
@@ -215,63 +302,63 @@ export async function runDoctorCommand(_argv: string[] = [], deps: DoctorDeps =
         "",
         renderTable(
           ["Companion Path", "Repository ID"],
-          resolution.ambiguousMatches.map((match) => [match.companionPath, match.repositoryId]),
+          report.multipleCompanions.map((match) => [match.companionPath, match.repositoryId]),
         ),
       ].join("\n"),
     );
   }
 
-  if (state === "linked-working-repository" && companionPath && repositoryId) {
-    const { configStore, workingRepoStore } = storesForCompanion(companionPath);
-    const config = await configStore.load();
-    let resolvedPolicy;
-
-    if (repository) {
-      resolvedPolicy = resolvePolicyFromConfig(config, [repository], repository.id);
-    } else {
-      resolvedPolicy = await new CompanionStore(configStore, workingRepoStore).resolvePolicy(
-        repositoryId,
-      );
-    }
-
-    if (!repository) {
-      const working = await workingRepoStore.load();
-      repository = working.repos.find((repo) => repo.id === repositoryId) ?? null;
-    }
-
+  if (report.policy) {
     printSection(
-      "Policy",
-      renderKeyValueTable([
-        ["Profile", repository?.profile ?? "unknown"],
-        ["Allowed Agents", resolvedPolicy.allowedAgents.join(", ") || "none"],
-      ]),
+      "Allowed Agents",
+      renderList(report.policy.allowedAgents, "No allowed agents configured."),
     );
+  }
+  if (report.policyError) printSection("Policy", report.policyError);
+  if (report.capabilities) printSection("Capabilities", renderCapabilities(report.capabilities));
+  if (report.toolInstallations) {
+    printSection("Tool Installations", renderToolInstallations(report.toolInstallations));
+  }
+  if (report.hub) printSection("Hub Members", renderHubMembers(report.hub.members));
+  // Companions with no drift produce no section at all: required plugins are
+  // silent when healthy.
+  if (report.requiredPluginDrift && report.requiredPluginDrift.length > 0) {
     printSection(
-      "Allowed Agents",
-      renderList(resolvedPolicy.allowedAgents, "No allowed agents configured."),
+      "Required Plugin Drift",
+      renderTable(
+        ["Plugin", "Kind", "Issue"],
+        report.requiredPluginDrift.map((entry) => [entry.pluginId, entry.kind, entry.reason]),
+      ),
     );
-    printSection("Capabilities", renderCapabilities(config.capabilities ?? []));
-    printSection("Tool Installations", renderToolInstallations(config, pathValue));
-    printRequiredPluginDrift(config);
-    printEngineRequirement(config);
-  } else if (state === "linked-working-repository") {
-    printSection("Policy", "No repository ID was provided for the resolved companion.");
-  } else if (companionPath) {
-    const { configStore } = storesForCompanion(companionPath);
-    const config = await configStore.load();
-    printSection("Capabilities", renderCapabilities(config.capabilities ?? []));
-    printSection("Tool Installations", renderToolInstallations(config, pathValue));
-    printRequiredPluginDrift(config);
-    printEngineRequirement(config);
+  }
+  if (report.engineRequirement) {
+    printSection("Version Requirement", report.engineRequirement.detail);
   }
 
   printSection(
     "Resolution Failures",
-    resolution.failures.length > 0
+    report.resolutionFailures.length > 0
       ? renderTable(
           ["Companion Path", "Error"],
-          resolution.failures.map((failure) => [failure.companionPath, failure.message]),
+          report.resolutionFailures.map((failure) => [failure.companionPath, failure.message]),
         )
       : "No companion resolution failures encountered.",
   );
 }
+
+/**
+ * @command mate doctor
+ * @description Reports the current directory's root kind — `working` (linked
+ * working repository), `companion`, `hub`, or `core` (not linked) — with
+ * kind-specific diagnostics: policy and capabilities for working repos,
+ * capabilities and tool checks for companions, member health for hubs.
+ * `--json` emits the same report as one JSON document.
+ */
+export async function runDoctorCommand(argv: string[] = [], deps: DoctorDeps = {}): Promise<void> {
+  const report = await collectDoctorReport(deps);
+  if (argv.includes("--json")) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  renderHumanReport(report);
+}

package/src/cli/commands/setup.ts

@@ -56,7 +56,7 @@ export async function runSetupCommand(argv: string[]): Promise<void> {
  * Resolves agent/package-manager/capability selections either from CLI flags
  * (non-interactive) or from the interactive `selectSetupCompatibilities` picker,
  * seeded from the existing config when one exists. Writes the resulting config
- * via `setup.execute` and prints a summary table of profiles, package managers,
+ * via `setup.execute` and prints a summary table of allowed agents, package managers,
  * and capabilities.
  * @flags
  * - `--agents <list>` — parsed via `parseAllowedAgents`.
@@ -192,9 +192,7 @@ async function runSetupFlow(
   const { config } = result;
   const rows: [string, string][] = [];
 
-  for (const [profileName, profile] of Object.entries(config.profiles)) {
-    rows.push([`profile:${profileName}`, (profile.allowedAgents ?? []).join(", ") || "(none)"]);
-  }
+  rows.push(["allowedAgents", (config.allowedAgents ?? []).join(", ") || "(none)"]);
 
   const capabilities = config.capabilities ?? [];
   rows.push(["packageManagers", (config.packageManagers ?? ["bun"]).join(", ") || "(none)"]);