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

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/tools/setup/runtime-documents.ts

@@ -1,291 +0,0 @@
-import path from "node:path";
-
-import { runtimeOpenCodePluginRoot } from "../../runtime/runtime-directory";
-import {
-  CLAUDE_LOCAL_CONFIG_DOCUMENT,
-  CLAUDE_SETTINGS_DOCUMENT,
-  OPENCODE_CONFIG_DOCUMENT,
-  OPENCODE_MCP_SERVERS_AT,
-  type ManagedRegion,
-  type RenderedRuntimeDocument,
-} from "../../runtime/runtime-document-manifest";
-import type { CapabilityContributionInput, SetupContext } from "./plugin";
-import {
-  mateBannerHookGroups,
-  mateGuardHookGroups,
-  mateGuidanceHookGroups,
-  mateSessionPrepareHookGroups,
-} from "./providers/claude-plugin-hooks";
-import {
-  renderManagedClaudeHookGroups,
-  renderManagedClaudeMcpServers,
-  renderManagedClaudePermissionEntries,
-} from "./providers/claude";
-import {
-  renderCompanionExternalDirectoryPermissions,
-  renderManagedOpenCodeMcpServers,
-} from "./providers/opencode";
-import { isRecord, readOpenCodeConfig } from "./providers/opencode-format";
-import { projectionRepoRoot } from "./surface-target";
-
-/**
- * The working target's documents, rendered as values. Each is a document the
- * runtime finds by walking up from the current directory, and every path inside
- * one still names the Companion Repository — only where the document is placed
- * differs from the companion target.
- */
-
-export { CLAUDE_LOCAL_CONFIG_DOCUMENT };
-
-function nonEmpty(region: ManagedRegion): boolean {
-  if (region.kind === "list") return region.values.length > 0;
-  if (region.kind === "map") return Object.keys(region.entries).length > 0;
-  return true;
-}
-
-function document(documentPath: string, regions: ManagedRegion[]): RenderedRuntimeDocument[] {
-  const kept = regions.filter(nonEmpty);
-  return kept.length > 0 ? [{ path: documentPath, regions: kept }] : [];
-}
-
-/**
- * The Mate plugin root is what makes an Unmanaged OpenCode session load the
- * companion guidance at all: OpenCode has no config channel for a generated
- * system prompt, so the plugin is the only injection point. It is named through
- * the runtime directory, so a reinstall does not strand a wrapped repository.
- * The managed launch carries no overlay of its own, so this document is the one
- * place every OpenCode session in the repository loads it from.
- */
-
-/**
- * Loaded by a managed session beside the launch's plugin. Mate hooks here run
- * twice there, inertly: guard is input-pure, guidance/prepare yield under a
- * launch env, banner is `--projected`. Capability groups run once: the launch
- * omits them from `--settings`. A launch passes no `--add-dir`; it relies on
- * `CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD` for companion `CLAUDE.md`.
- */
-function claudeSettingsRegions(
-  ctx: SetupContext,
-  inputs: CapabilityContributionInput[],
-): ManagedRegion[] {
-  const capabilityHooks = renderManagedClaudeHookGroups(inputs);
-  const mateHooks: Record<string, unknown[]> = {
-    PreToolUse: mateGuardHookGroups(),
-    SessionStart: [
-      ...mateBannerHookGroups(),
-      ...mateGuidanceHookGroups(),
-      ...mateSessionPrepareHookGroups(),
-    ],
-  };
-  const events = [...new Set([...Object.keys(mateHooks), ...Object.keys(capabilityHooks)])];
-  return [
-    ...events.map((event): ManagedRegion => ({
-      at: ["hooks", event],
-      kind: "list",
-      values: [...(mateHooks[event] ?? []), ...(capabilityHooks[event] ?? [])],
-    })),
-    /**
-     * `stripPrefix` heals a repository an older Mate wrapped. That version wrote
-     * the whole launch environment here, and Claude Code applies `env` to the
-     * session, so every hook in a bare session inherited `MATE_*` and read the
-     * repository as a Managed Session — silently, since looking managed is
-     * exactly what makes the guidance hook emit nothing. Guidance must be the
-     * projection's to give in an Unmanaged Session, so no `MATE_*` key may
-     * survive here.
-     */
-    {
-      at: ["env"],
-      kind: "map",
-      entries: { CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD: "1" },
-      stripPrefix: "MATE_",
-    },
-    {
-      at: ["permissions", "allow"],
-      kind: "list",
-      values: renderManagedClaudePermissionEntries(ctx.companionPath, inputs),
-    },
-  ];
-}
-
-export function renderDocumentsForTarget(
-  ctx: SetupContext,
-  inputsByRuntime: Map<string, CapabilityContributionInput[]>,
-): RenderedRuntimeDocument[] {
-  const repoRoot = projectionRepoRoot(ctx);
-
-  const documents: RenderedRuntimeDocument[] = [];
-  if (ctx.activeProviders.includes("claude")) {
-    const inputs = inputsByRuntime.get("claude") ?? [];
-    documents.push(...document(CLAUDE_SETTINGS_DOCUMENT, claudeSettingsRegions(ctx, inputs)));
-    /**
-     * Local scope, not `.mcp.json`: a project-scoped server is inert until a
-     * human approves it in a session, which an Unmanaged Session is exactly the
-     * case that cannot rely on. The repo path is the key Claude Code files a
-     * project under, resolved so a symlinked working directory still matches.
-     *
-     * Confirmed against a real `~/.claude.json`: the keys there are the
-     * directories sessions started in, not repository roots — sibling
-     * directories of one checkout each hold their own entry, as do temporary
-     * directories. So this reaches exactly one session: the one started at the
-     * repository root. A session started in a subdirectory of a wrapped
-     * repository has its own key, finds no `mcpServers` under it, and sees none
-     * of these servers — the Unmanaged Session case this document exists for,
-     * missed. That limit is deliberate. The directories a session might start
-     * in are unbounded, and every one of them would be a fresh entry in the
-     * user's global configuration that nothing later reclaims; keying the
-     * repository root only keeps the projection's footprint there to a single
-     * key. A subdirectory session still gets the rest of the projection — the
-     * documents inside the repository are found by the runtime's own upward
-     * walk — it loses only the MCP servers.
-     */
-    documents.push(
-      ...document(CLAUDE_LOCAL_CONFIG_DOCUMENT, [
-        {
-          at: ["projects", repoRoot, "mcpServers"],
-          kind: "map",
-          entries: renderManagedClaudeMcpServers(inputs),
-        },
-      ]),
-    );
-  }
-  if (ctx.activeProviders.includes("opencode")) {
-    const inputs = inputsByRuntime.get("opencode") ?? [];
-    documents.push(
-      ...document(OPENCODE_CONFIG_DOCUMENT, [
-        {
-          at: ["plugins"],
-          kind: "list",
-          values: [runtimeOpenCodePluginRoot()],
-        },
-        {
-          at: [...OPENCODE_MCP_SERVERS_AT],
-          kind: "map",
-          entries: renderManagedOpenCodeMcpServers(inputs),
-        },
-        {
-          at: ["permissions"],
-          kind: "list",
-          values: renderCompanionExternalDirectoryPermissions(ctx.companionPath),
-        },
-        {
-          at: ["skills"],
-          kind: "list",
-          values: [path.join(ctx.companionPath, ".agents", "skills")],
-        },
-        { at: ["references"], kind: "map", entries: { mate: ctx.companionPath } },
-      ]),
-    );
-  }
-  return documents;
-}
-
-/** Keys Mate renders its own regions for; the companion's values join those regions. */
-const MATE_OPENCODE_KEYS = new Set(["plugins", "permissions", "skills", "mcp", "references"]);
-
-function relativePathValues(value: unknown, at: string[]): string[] {
-  if (typeof value === "string") {
-    return value.startsWith("./") || value.startsWith("../") ? [at.join(".")] : [];
-  }
-  if (Array.isArray(value)) {
-    return value.flatMap((entry, index) => relativePathValues(entry, [...at, String(index)]));
-  }
-  if (isRecord(value)) {
-    return Object.entries(value).flatMap(([key, entry]) => relativePathValues(entry, [...at, key]));
-  }
-  return [];
-}
-
-/** Replaces the region at `at` with what `merge` builds from it, or appends one. */
-function upsertRegion(
-  regions: ManagedRegion[],
-  at: string[],
-  merge: (found: ManagedRegion | undefined) => ManagedRegion,
-): void {
-  const key = JSON.stringify(at);
-  const index = regions.findIndex((region) => JSON.stringify(region.at) === key);
-  if (index === -1) regions.push(merge(undefined));
-  else regions[index] = merge(regions[index]);
-}
-
-/** Mate's own values stay; companion values it does not already list go first. */
-function mergeListRegion(regions: ManagedRegion[], at: string[], extra: unknown[]): void {
-  upsertRegion(regions, at, (found) => {
-    const own = found?.kind === "list" ? found.values : [];
-    const seen = new Set(own.map((value) => JSON.stringify(value)));
-    const values = [...extra.filter((value) => !seen.has(JSON.stringify(value))), ...own];
-    return { at, kind: "list", values };
-  });
-}
-
-/** Mate's own entries win over companion entries of the same name. */
-function mergeMapRegion(
-  regions: ManagedRegion[],
-  at: string[],
-  extra: Record<string, unknown>,
-): void {
-  upsertRegion(regions, at, (found) => {
-    const own = found?.kind === "map" ? found.entries : {};
-    return { at, kind: "map", entries: { ...extra, ...own } };
-  });
-}
-
-/** Relative reference paths resolved against the companion's `.opencode/`. */
-function resolveReferences(
-  references: Record<string, unknown>,
-  companionDir: string,
-): Record<string, unknown> {
-  return Object.fromEntries(
-    Object.entries(references).map(([name, reference]) => [
-      name,
-      typeof reference === "string" && !path.isAbsolute(reference)
-        ? path.resolve(companionDir, reference)
-        : reference,
-    ]),
-  );
-}
-
-/**
- * Folds the companion's `.opencode/opencode.json` into the wrapped document.
- * Mate's regions beat companion values; other top-level keys yield to the
- * repository's. `references` resolve against the companion's `.opencode/`;
- * other relative paths are reported, not rewritten.
- */
-export async function mergeCompanionOpenCodeConfig(
-  companionPath: string,
-  documents: RenderedRuntimeDocument[],
-): Promise<{ documents: RenderedRuntimeDocument[]; warnings: string[] }> {
-  const index = documents.findIndex((document) => document.path === OPENCODE_CONFIG_DOCUMENT);
-  const companionConfigPath = path.join(companionPath, ".opencode", "opencode.json");
-  const companion = index === -1 ? null : await readOpenCodeConfig(companionConfigPath);
-  if (!companion?.present) return { documents, warnings: [] };
-
-  const regions = [...documents[index]!.regions] as ManagedRegion[];
-  const warnings: string[] = [];
-
-  const companionDir = path.dirname(companionConfigPath);
-  for (const [key, value] of Object.entries(companion.config)) {
-    if (key === "$schema") continue;
-    if (key === "references" && isRecord(value)) {
-      mergeMapRegion(regions, ["references"], resolveReferences(value, companionDir));
-      continue;
-    }
-    for (const at of relativePathValues(value, [key])) {
-      warnings.push(
-        `${companionConfigPath}: ${at} is a relative path, which resolves against the working repository once merged into ${OPENCODE_CONFIG_DOCUMENT}; use an absolute path.`,
-      );
-    }
-    if (MATE_OPENCODE_KEYS.has(key)) {
-      if (key === "mcp" && isRecord(value) && isRecord(value.servers)) {
-        mergeMapRegion(regions, [...OPENCODE_MCP_SERVERS_AT], value.servers);
-      } else if (Array.isArray(value)) {
-        mergeListRegion(regions, [key], value);
-      }
-      continue;
-    }
-    regions.push({ at: [key], kind: "value", value, yields: true });
-  }
-
-  const next = [...documents];
-  next[index] = { path: OPENCODE_CONFIG_DOCUMENT, regions };
-  return { documents: next, warnings };
-}