@uniqbit/mate-core 0.18.4 → 1.0.0-canary.0

package/wrappers/bin/openspec

@@ -50,16 +50,25 @@ if [ -z "$_companion" ]; then
 fi
 [ -n "$_companion" ] || { echo "openspec: no mate context here — run \`mate wrap\` in this repository" >&2; exit 1; }
 
+# The OpenSpec CLI Mate ships with, found the way Node resolves it: upward from
+# the package root, hoisted or nested under mate-core (distribution packages).
+# Never an openspec on PATH, so a global install of another version is ignored.
+# Physical path: the runtime directory reaches wrappers/ through a symlink.
 _real=""
-IFS=:
-for _dir in $PATH; do
-    [ "$_dir" = "$_this_dir" ] && continue
-    [ -x "$_dir/openspec" ] || continue
-    _real="$_dir/openspec"
-    break
+_dir="$(cd -P "$_this_dir" && cd ../.. && pwd -P)"
+while [ -z "$_real" ]; do
+  for _candidate in \
+    "$_dir/node_modules/@fission-ai/openspec/bin/openspec.js" \
+    "$_dir/node_modules/@uniqbit/mate-core/node_modules/@fission-ai/openspec/bin/openspec.js"; do
+    if [ -f "$_candidate" ]; then
+      _real="$_candidate"
+      break 2
+    fi
+  done
+  [ "$_dir" = "/" ] && break
+  _dir="$(dirname "$_dir")"
 done
-unset IFS
-[ -n "$_real" ] || { echo "openspec wrapper: real binary not found in PATH" >&2; exit 1; }
+[ -n "$_real" ] || { echo "openspec: bundled OpenSpec CLI is missing. Reinstall Mate to restore it." >&2; exit 1; }
 command="${1-}"
 if [ "$command" = "templates" ]; then
   has_schema=0
@@ -133,4 +142,19 @@ case "$command" in
     _mate_use_store_pointer
     ;;
 esac
-exec env -C "$_cwd" "$_real" "$@"
+# A JS entry's `#!/usr/bin/env node` shebang needs an executable bit and `node`
+# on PATH; without either (Bun-only installs) it runs on an explicit runtime.
+_shebang=""
+[ "${_real%.js}" != "$_real" ] && { IFS= read -r _shebang < "$_real" || true; }
+if [ -n "$_shebang" ] && {
+  [ ! -x "$_real" ] ||
+    { [ "$_shebang" = "#!/usr/bin/env node" ] && ! command -v node >/dev/null 2>&1; }
+}; then
+  _runtime="$(command -v node || command -v bun || true)"
+  [ -n "$_runtime" ] || { echo "openspec: neither node nor bun is on PATH to run $_real" >&2; exit 1; }
+  set -- "$_real" "$@"
+  _real="$_runtime"
+fi
+# Mate decides the OpenSpec version, so OpenSpec's update hint is wrong advice
+# here; both variables reach the delegated binary only.
+exec env -C "$_cwd" OPENSPEC_TELEMETRY=0 OPENSPEC_NO_UPDATE_CHECK=1 "$_real" "$@"

package/wrappers/lib/graphify-gate.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+// Thin shim: the gate lives in src/tools/setup/capabilities/graphify-gate.ts,
+// loaded through the plugin's ts-loader because the installed package sits
+// inside node_modules where node's native type stripping is disabled.
+import "../../claude-plugin/hooks/ts-loader.mjs";
+
+const { runGraphifyGate } = await import("../../src/tools/setup/capabilities/graphify-gate.ts");
+process.exitCode = await runGraphifyGate(process.argv.slice(2));

package/opencode-plugin/src/audience-layer.ts

@@ -1,91 +0,0 @@
-import type { Context } from "@opencode/plugin/promise/plugin";
-
-import { repositoryWrappedForOpenCode } from "../../src/opencode/companion-hooks";
-import { currentAudienceLayer } from "../../src/runtime/audience-layer";
-import { MATE_ENV } from "../../src/runtime/env";
-import { parseGuidanceContent } from "../../src/runtime/guidance";
-import {
-  readOpenCodeAudienceLayer,
-  type OpenCodeLayerContents,
-} from "../../src/runtime/opencode-audience-layer";
-import { readWrapStateSync } from "../../src/runtime/wrap-state";
-import type { LaunchEnvironment } from "./launch-environment";
-
-export interface TrustedAudienceLayer {
-  root: string;
-  contents: OpenCodeLayerContents;
-}
-
-/**
- * The audience layer named by a payload the plugin trusts. `env` is the
- * launch environment `pluginLaunchEnvironment` decided on, so a masked
- * payload, a bare session and the shared service all read as `{}` here and
- * never apply a layer.
- */
-export async function readTrustedAudienceLayer(
-  env: LaunchEnvironment,
-): Promise<TrustedAudienceLayer | null> {
-  const payload = env[MATE_ENV.guidanceJson];
-  if (!payload?.trim()) return null;
-  const root = parseGuidanceContent(payload).guidance.audienceLayer;
-  if (!root) return null;
-  return { root, contents: await readOpenCodeAudienceLayer(root) };
-}
-
-/**
- * The layer of the audience the session's checkout is wrapped for. The wrap is
- * resolved from the session's own directory, so the shared service serves each
- * checkout its own audience; the environment never selects one.
- */
-export async function readWrappedAudienceLayer(
-  directory: string,
-  companionPath: string,
-): Promise<TrustedAudienceLayer | null> {
-  const repoRoot = repositoryWrappedForOpenCode(directory);
-  if (!repoRoot) return null;
-  const audience = readWrapStateSync(repoRoot).audience;
-  if (!audience) return null;
-  const root = currentAudienceLayer(companionPath, audience);
-  return root ? { root, contents: await readOpenCodeAudienceLayer(root) } : null;
-}
-
-/**
- * Applies a layer's MCP servers, skills and agents through the plugin API. A
- * new agent id is created by updating it; its prompt goes in `system`.
- */
-export async function registerAudienceLayer(
-  api: Context,
-  layer: OpenCodeLayerContents,
-): Promise<void> {
-  if (layer.mcpServers.length > 0) {
-    await api.mcp.transform((editor) => {
-      for (const server of layer.mcpServers) editor.set(server.name, server.config as never);
-    });
-  }
-
-  if (layer.skills.length > 0) {
-    await api.skill.transform((editor) => {
-      for (const skill of layer.skills) {
-        if (editor.get(skill.id)) {
-          editor.update(skill.id, (current) => Object.assign(current, skill));
-        } else {
-          editor.add(skill as never);
-        }
-      }
-    });
-  }
-
-  if (layer.agents.length > 0) {
-    await api.agent.transform((editor) => {
-      for (const agent of layer.agents) {
-        editor.update(agent.id, (current) => {
-          const target = current as Record<string, unknown>;
-          target.name ??= agent.id;
-          if (agent.description) target.description = agent.description;
-          target.mode = agent.mode;
-          target.system = agent.system;
-        });
-      }
-    });
-  }
-}

package/src/cli/commands/studio/views/workflow/transcript.tsx

@@ -1,190 +0,0 @@
-/** @jsxImportSource hono/jsx */
-
-import type { StudioCompanionPayload } from "../../payload";
-import {
-  workflowPlan,
-  type WorkflowBranch,
-  type WorkflowStep,
-  type WorkflowStepBadge,
-} from "./steps";
-
-type WorkflowPlan = ReturnType<typeof workflowPlan>;
-
-export function WorkflowTranscript({ payload }: { payload: StudioCompanionPayload }) {
-  return <CommandTranscript plan={workflowPlan(payload.skills)} />;
-}
-
-function CommandTranscript({ plan }: { plan: WorkflowPlan }) {
-  return (
-    <section className="workflow-console" aria-label="Workflow execution map">
-      <header className="workflow-console-header">
-        <div className="workflow-console-header-title">
-          <span>Workflow map</span>
-          <strong>Companion delivery path</strong>
-        </div>
-        <span>Read-only guide</span>
-      </header>
-      <div className="workflow-console-body">
-        <ConsoleLine step={plan.start} marker="01" />
-        <div className="workflow-console-context">
-          <span>precondition</span>
-          <div>
-            <p>The desired change, its scope, and the risk involved are clear.</p>
-            <small>If any of that is unclear, pre-explore above resolves it first.</small>
-          </div>
-        </div>
-        <div className="workflow-console-schema" data-workflow-schema-root>
-          <div
-            className="workflow-console-tabs"
-            data-workflow-schema-switch
-            role="tablist"
-            aria-label="Planning depth"
-          >
-            {plan.branches.map((branch, index) => (
-              <button
-                key={branch.profile}
-                type="button"
-                role="tab"
-                data-workflow-schema-profile={branch.profile}
-                aria-selected={index === 0}
-              >
-                <strong>{branch.label}</strong>
-                <small>{index === 0 ? "full planning" : "minimal planning"}</small>
-              </button>
-            ))}
-          </div>
-          <div className="workflow-console-panels">
-            {plan.branches.map((branch, branchIndex) => (
-              <section
-                key={branch.profile}
-                data-workflow-schema-panel={branch.profile}
-                data-active={branchIndex === 0 ? "true" : "false"}
-                role="tabpanel"
-              >
-                <div className="workflow-console-branch-rule">
-                  <p className="workflow-console-branch-rule-description">
-                    {planningRule(branch.profile)}
-                  </p>
-                </div>
-                {branch.steps.map((step, index) => (
-                  <div key={step.id}>
-                    {step.sessionBreakBefore ? <WorkflowSessionBreak /> : null}
-                    <ConsoleLine
-                      step={step}
-                      marker={`${branchIndex === 0 ? "F" : "M"}${String(index + 1).padStart(2, "0")}`}
-                    />
-                  </div>
-                ))}
-              </section>
-            ))}
-          </div>
-        </div>
-        <div className="workflow-console-divider">paths rejoin</div>
-        {plan.shared.map((step) => (
-          <div key={step.id}>
-            {step.sessionBreakBefore ? <WorkflowSessionBreak /> : null}
-            <ConsoleLine step={step} marker="+" />
-          </div>
-        ))}
-        <div className="workflow-console-divider">feature is on production</div>
-        <ConsoleLine step={plan.finish} marker="END" />
-      </div>
-    </section>
-  );
-}
-
-function planningRule(profile: WorkflowBranch["profile"]): string {
-  return profile === "mate-v1"
-    ? "Use when intent is clear, but the solution, repository evidence, or risk still needs exploration."
-    : "Use only when intent and scope are clear, the change is low-risk, and it stays within one Area.";
-}
-
-function ConsoleLine({ step, marker }: { step: WorkflowStep; marker: string }) {
-  const hasAlternatives = Boolean(step.alternatives?.length);
-
-  return (
-    <article className="workflow-console-line">
-      <span className="workflow-console-gutter">{marker}</span>
-      <div className="workflow-console-line-body">
-        <div className="workflow-console-step-title">
-          <strong>{step.title}</strong>
-          <WorkflowBadges badges={step.badges} />
-        </div>
-        {!hasAlternatives ? (
-          step.kind === "review" ? (
-            <div className="workflow-console-command workflow-console-review">
-              <span className="workflow-console-command-label">Review</span>
-              <code>{step.prompt}</code>
-            </div>
-          ) : (
-            <div className="workflow-console-command">
-              <span className="workflow-console-command-label">Run</span>
-              <code>{step.prompt}</code>
-              <WorkflowCopy text={step.copyPrompt} label={`${step.title} prompt`} />
-            </div>
-          )
-        ) : null}
-        {hasAlternatives ? <WorkflowOptions step={step} /> : null}
-        <div className="workflow-console-explanation">
-          <div className="workflow-console-detail">
-            <span>What</span>
-            <p>{step.what}</p>
-          </div>
-          <div className="workflow-console-detail">
-            <span>Why</span>
-            <small>{step.why}</small>
-          </div>
-        </div>
-        {!hasAlternatives ? <WorkflowOptions step={step} /> : null}
-      </div>
-    </article>
-  );
-}
-
-function WorkflowOptions({ step }: { step: WorkflowStep }) {
-  if (!step.alternatives?.length) return null;
-  return (
-    <div className="workflow-option-list">
-      {step.alternatives.map((alternative) => (
-        <div key={alternative.name} className="workflow-option">
-          <div className="workflow-console-command">
-            <span className="workflow-console-command-label">Option</span>
-            <code>{alternative.prompt}</code>
-            <WorkflowCopy text={alternative.copyPrompt} label={`${alternative.name} prompt`} />
-          </div>
-          <small>{alternative.description}</small>
-        </div>
-      ))}
-    </div>
-  );
-}
-
-function WorkflowCopy({ text, label }: { text: string; label: string }) {
-  return (
-    <button type="button" className="runway-step-copy" data-copy={text} data-copy-label={label}>
-      Copy
-    </button>
-  );
-}
-
-function WorkflowSessionBreak() {
-  return <div className="workflow-session-break">New session / clean chat</div>;
-}
-
-function WorkflowBadges({ badges }: { badges: WorkflowStepBadge[] }) {
-  return (
-    <span className="workflow-badges">
-      {badges.map((badge) => (
-        <em key={badge} className={`runway-step-badge runway-step-badge-${badge}`}>
-          {badgeLabel(badge)}
-        </em>
-      ))}
-    </span>
-  );
-}
-
-function badgeLabel(badge: WorkflowStepBadge): string {
-  if (badge === "human-in-loop") return "Review";
-  if (badge === "openspec") return "OpenSpec";
-  return badge;
-}

package/src/runtime/audience-layer.ts

@@ -1,84 +0,0 @@
-import crypto from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-
-import { FRAMEWORK_NAME } from "./framework";
-import { mateHome } from "./runtime-directory";
-
-/**
- * Audience Layer locations. A layer holds one audience's plugin contributions
- * for one companion, rendered for managed launches only. It lives under Mate's
- * machine-local state, never inside a repository: a layer inside the companion
- * would be readable by every session with companion access, and could carry
- * values resolved from plugin configuration.
- *
- *   <state>/audience-layers/<companion-key>/<audience>/
- *     <fingerprint>/   one complete render; never changed once renamed into place
- *     current          symlink to the newest complete render
- *
- * A launch attaches the fingerprint directory itself, so a later re-render
- * never changes what a running session reads.
- */
-
-/** Mirrors `AUDIENCE_NAME_PATTERN`; repeated here because `runtime/` imports nothing from core. */
-const SAFE_AUDIENCE = /^[a-z][a-z0-9-]{0,63}$/;
-
-export const CURRENT_LAYER_LINK = "current";
-
-export function audienceLayersRoot(homeDir?: string): string {
-  return path.join(mateHome(homeDir), "state", "audience-layers");
-}
-
-/** A short, stable key for one companion checkout: a hash of its resolved path. */
-export function companionLayerKey(companionPath: string): string {
-  return crypto.createHash("sha256").update(path.resolve(companionPath)).digest("hex").slice(0, 16);
-}
-
-/** The directory holding one audience's layers for one companion. */
-export function audienceLayerDir(
-  companionPath: string,
-  audience: string,
-  homeDir?: string,
-): string {
-  if (!SAFE_AUDIENCE.test(audience)) {
-    throw new Error(`"${audience}" is not a valid audience name for a layer directory`);
-  }
-  return path.join(audienceLayersRoot(homeDir), companionLayerKey(companionPath), audience);
-}
-
-/** The newest complete layer of `audience`, or `null` when none was rendered on this machine. */
-export function currentAudienceLayer(
-  companionPath: string,
-  audience: string,
-  homeDir?: string,
-): string | null {
-  try {
-    const dir = audienceLayerDir(companionPath, audience, homeDir);
-    const layer = path.join(dir, fs.readlinkSync(path.join(dir, CURRENT_LAYER_LINK)));
-    return fs.existsSync(layer) ? layer : null;
-  } catch {
-    return null;
-  }
-}
-
-const MANAGED_MARKER = new RegExp(
-  `^<!-- ${FRAMEWORK_NAME}:managed:[^\\n]* (?:start|end) -->$`,
-  "gm",
-);
-
-/** A layer guidance document's text, managed-block markers removed; empty when absent. */
-export function layerGuidanceText(text: string): string {
-  return text
-    .replace(MANAGED_MARKER, "")
-    .replace(/\n{3,}/g, "\n\n")
-    .trim();
-}
-
-/** `file` (`CLAUDE.md`, `AGENTS.md`) of the layer at `root`, markers removed; empty when absent. */
-export function readLayerGuidanceSync(root: string, file: string): string {
-  try {
-    return layerGuidanceText(fs.readFileSync(path.join(root, file), "utf8"));
-  } catch {
-    return "";
-  }
-}

package/src/runtime/opencode-audience-layer.ts

@@ -1,176 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-
-import { layerGuidanceText } from "./audience-layer";
-import { OPENCODE_MCP_SERVERS_AT } from "./runtime-document-manifest";
-
-/**
- * Reads an audience layer the OpenCode Runtime Surface wrote, as what the Mate
- * OpenCode plugin applies through the plugin API. The surface re-exports it as
- * its own reader; it lives under `runtime/` only so the import-isolated plugin
- * can reach it. The plugin parses no OpenCode document itself.
- */
-
-export interface LayerMcpServer {
-  name: string;
-  /** The entry exactly as the surface wrote it under `mcp.servers`. */
-  config: Record<string, unknown>;
-}
-
-export interface LayerSkill {
-  id: string;
-  name: string;
-  description?: string;
-  /** The skill's `SKILL.md`. */
-  path: string;
-  content: string;
-}
-
-export type LayerAgentMode = "subagent" | "primary" | "all";
-
-export interface LayerAgent {
-  id: string;
-  description?: string;
-  mode: LayerAgentMode;
-  /** The agent's prompt: the definition's body. */
-  system: string;
-}
-
-export interface OpenCodeLayerContents {
-  mcpServers: LayerMcpServer[];
-  skills: LayerSkill[];
-  agents: LayerAgent[];
-  /** The layer's guidance sections, managed-block markers removed. */
-  guidance: string;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function splitFrontmatter(content: string): { fields: string; body: string } {
-  const match = content.match(/^---\s*\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
-  return match
-    ? { fields: match[1]!, body: content.slice(match[0].length) }
-    : { fields: "", body: content };
-}
-
-function frontmatterScalarFromFields(fields: string, key: string): string | undefined {
-  const value = fields.match(new RegExp(`^${key}:\\s*(.+)$`, "m"))?.[1]?.trim();
-  return value?.replace(
-    /^(?:"([\s\S]*)"|'([\s\S]*)')$/,
-    (_all, doubleQuoted?: string, singleQuoted?: string) => doubleQuoted ?? singleQuoted ?? "",
-  );
-}
-
-/** One scalar of a simple YAML frontmatter, quotes removed. */
-export function frontmatterScalar(content: string, key: string): string | undefined {
-  return frontmatterScalarFromFields(splitFrontmatter(content).fields, key);
-}
-
-/** An id OpenCode accepts for a skill or agent name. */
-export function contributionId(name: string, fallback: string): string {
-  return (
-    name
-      .toLowerCase()
-      .replace(/[^a-z0-9_-]+/g, "-")
-      .replace(/^-+|-+$/g, "") || fallback
-  );
-}
-
-async function findSkillFiles(directory: string): Promise<string[]> {
-  try {
-    const entries = await fs.readdir(directory, { withFileTypes: true });
-    const nested = await Promise.all(
-      entries.map((entry) => {
-        const entryPath = path.join(directory, entry.name);
-        if (entry.isFile() && entry.name === "SKILL.md") return Promise.resolve([entryPath]);
-        return entry.isDirectory() ? findSkillFiles(entryPath) : Promise.resolve([]);
-      }),
-    );
-    return nested.flat().toSorted();
-  } catch {
-    return [];
-  }
-}
-
-/** Every `SKILL.md` under `roots`; an unreadable skill is skipped, never fatal. */
-export async function loadSkillInfos(roots: readonly string[]): Promise<LayerSkill[]> {
-  const files = (await Promise.all(roots.map(findSkillFiles))).flat();
-  const skills = await Promise.all(
-    files.map(async (filePath): Promise<LayerSkill | null> => {
-      try {
-        const content = await fs.readFile(filePath, "utf8");
-        const { fields } = splitFrontmatter(content);
-        const name =
-          frontmatterScalarFromFields(fields, "name") || path.basename(path.dirname(filePath));
-        const description = frontmatterScalarFromFields(fields, "description");
-        return {
-          id: contributionId(name, "mate-skill"),
-          name,
-          ...(description ? { description } : {}),
-          path: filePath,
-          content,
-        };
-      } catch {
-        return null;
-      }
-    }),
-  );
-  return skills.filter((skill) => skill !== null);
-}
-
-async function readMcpServers(root: string): Promise<LayerMcpServer[]> {
-  const parsed = await fs
-    .readFile(path.join(root, ".opencode", "opencode.json"), "utf8")
-    .then((text) => JSON.parse(text) as unknown)
-    .catch(() => null);
-  let servers: unknown = parsed;
-  for (const key of OPENCODE_MCP_SERVERS_AT) servers = isRecord(servers) ? servers[key] : undefined;
-  if (!isRecord(servers)) return [];
-  return Object.entries(servers)
-    .filter((entry): entry is [string, Record<string, unknown>] => isRecord(entry[1]))
-    .map(([name, config]) => ({ name, config }))
-    .toSorted((left, right) => left.name.localeCompare(right.name));
-}
-
-function agentMode(value: string | undefined): LayerAgentMode {
-  return value === "subagent" || value === "primary" ? value : "all";
-}
-
-async function readAgents(root: string): Promise<LayerAgent[]> {
-  const dir = path.join(root, ".opencode", "agents");
-  const names = await fs.readdir(dir).catch(() => [] as string[]);
-  const agents = await Promise.all(
-    names
-      .filter((name) => name.endsWith(".md"))
-      .toSorted()
-      .map(async (name): Promise<LayerAgent | null> => {
-        const content = await fs.readFile(path.join(dir, name), "utf8").catch(() => null);
-        if (content === null) return null;
-        const { fields, body } = splitFrontmatter(content);
-        const description = frontmatterScalarFromFields(fields, "description");
-        return {
-          id: contributionId(path.basename(name, ".md"), "mate-agent"),
-          ...(description ? { description } : {}),
-          mode: agentMode(frontmatterScalarFromFields(fields, "mode")),
-          system: body.trim(),
-        };
-      }),
-  );
-  return agents.filter((agent) => agent !== null);
-}
-
-async function readGuidance(root: string): Promise<string> {
-  return layerGuidanceText(await fs.readFile(path.join(root, "AGENTS.md"), "utf8").catch(() => ""));
-}
-
-export async function readOpenCodeAudienceLayer(root: string): Promise<OpenCodeLayerContents> {
-  const [mcpServers, skills, agents, guidance] = await Promise.all([
-    readMcpServers(root),
-    loadSkillInfos([path.join(root, ".agents", "skills")]),
-    readAgents(root),
-    readGuidance(root),
-  ]);
-  return { mcpServers, skills, agents, guidance };
-}