@flyingrobots/graft 0.7.0 → 0.7.1

package/src/mcp/secret-scrub.ts

@@ -1,89 +0,0 @@
-// ---------------------------------------------------------------------------
-// Secret scrubbing — shared redaction for observability and capture logs
-// ---------------------------------------------------------------------------
-
-const PRIVATE_KEY_BLOCK_RE = /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g;
-const SECRET_ASSIGNMENT_RE = /(\b(?:api[_-]?key|access[_-]?token|auth(?:orization)?|bearer|token|secret|password|passwd|private[_-]?key|client[_-]?secret|session[_-]?key)\b\s*[:=]\s*)([^\r\n]+)/gi;
-const BEARER_TOKEN_RE = /(\bbearer\s+)([A-Za-z0-9._~+/=-]{8,})/gi;
-
-/**
- * Keys whose values should always be redacted in observability logs,
- * regardless of the value's content.
- */
-const SENSITIVE_ARG_KEYS = new Set([
-  "token",
-  "apiKey",
-  "api_key",
-  "secret",
-  "password",
-  "passwd",
-  "access_token",
-  "accessToken",
-  "authorization",
-  "auth",
-  "bearer",
-  "private_key",
-  "privateKey",
-  "client_secret",
-  "clientSecret",
-  "session_key",
-  "sessionKey",
-  "credentials",
-]);
-
-/** Maximum string value length before truncation in observability logs. */
-const MAX_VALUE_LENGTH = 512;
-
-/**
- * Scrub secret patterns from a free-text string (e.g. shell output).
- * Returns the scrubbed text and how many redactions were applied.
- */
-export function scrubSecrets(output: string): {
-  readonly value: string;
-  readonly redactions: number;
-} {
-  let redactions = 0;
-  let value = output.replace(PRIVATE_KEY_BLOCK_RE, () => {
-    redactions++;
-    return "[REDACTED PRIVATE KEY BLOCK]";
-  });
-  value = value.replace(SECRET_ASSIGNMENT_RE, (_match, prefix: string) => {
-    redactions++;
-    return `${prefix}[REDACTED]`;
-  });
-  value = value.replace(BEARER_TOKEN_RE, (_match, prefix: string) => {
-    redactions++;
-    return `${prefix}[REDACTED]`;
-  });
-  return { value, redactions };
-}
-
-/**
- * Sanitize a tool's argument map for observability logging.
- * Returns a safe-to-persist record with:
- *   - sensitive keys redacted
- *   - oversized string values truncated
- *   - non-string values preserved as-is (they're JSON-safe)
- */
-export function sanitizeArgValues(
-  args: Record<string, unknown>,
-): Record<string, unknown> {
-  const sanitized: Record<string, unknown> = {};
-  for (const key of Object.keys(args).sort()) {
-    if (SENSITIVE_ARG_KEYS.has(key)) {
-      sanitized[key] = "[REDACTED]";
-      continue;
-    }
-    const value = args[key];
-    if (typeof value === "string") {
-      if (value.length > MAX_VALUE_LENGTH) {
-        sanitized[key] = `${value.slice(0, MAX_VALUE_LENGTH)}... [truncated, ${String(value.length)} chars]`;
-      } else {
-        sanitized[key] = scrubSecrets(value).value;
-      }
-    } else {
-      sanitized[key] = value;
-    }
-  }
-  return sanitized;
-}

package/src/mcp/semantic-transition-guidance.ts

@@ -1,60 +0,0 @@
-import type { CausalSurfaceNextAction } from "../contracts/causal-surface-next-action.js";
-import type { PersistedLocalHistorySummary } from "./persisted-local-history.js";
-import type { RepoConcurrencySummary } from "./repo-concurrency.js";
-import type { RepoObservation } from "./repo-state.js";
-
-export function deriveCausalSurfaceNextAction(
-  summaryNextAction: PersistedLocalHistorySummary["nextAction"],
-  semanticTransition: RepoObservation["semanticTransition"],
-  repoConcurrency: RepoConcurrencySummary | null,
-): CausalSurfaceNextAction {
-  if (
-    summaryNextAction === "bind_workspace_to_begin_local_history"
-    || summaryNextAction === "inspect_or_resume_local_history"
-  ) {
-    return summaryNextAction;
-  }
-
-  if (semanticTransition !== null) {
-    switch (semanticTransition.kind) {
-      case "conflict_resolution":
-        return "resolve_conflicts_before_continuing";
-      case "merge_phase":
-        return semanticTransition.phase === "completed_or_cleared"
-          ? summaryNextAction
-          : "complete_merge_phase_before_continuing";
-      case "rebase_phase":
-        return semanticTransition.phase === "completed_or_cleared"
-          ? summaryNextAction
-          : "continue_rebase_phase_before_continuing";
-      case "bulk_transition":
-        return "inspect_bulk_transition_scope_before_continuing";
-      case "index_update":
-      case "unknown":
-        break;
-    }
-  }
-
-  if (repoConcurrency === null) {
-    return summaryNextAction;
-  }
-
-  switch (repoConcurrency.posture) {
-    case "divergent_checkout":
-      return "review_divergent_checkout_before_continuing";
-    case "shared_worktree":
-      if (summaryNextAction === "review_transition_boundary_before_continuing") {
-        return summaryNextAction;
-      }
-      return "coordinate_shared_worktree_before_continuing";
-    case "overlapping_actors":
-      if (summaryNextAction === "review_transition_boundary_before_continuing") {
-        return summaryNextAction;
-      }
-      return "inspect_overlapping_actor_activity_before_continuing";
-    case "exclusive":
-    case "shared_repo_only":
-    case "unknown":
-      return summaryNextAction;
-  }
-}

package/src/mcp/semantic-transition-summary.ts

@@ -1,130 +0,0 @@
-interface SemanticTransitionSummaryEvidence {
-  readonly totalPaths: number;
-  readonly stagedPaths: number;
-  readonly changedPaths: number;
-  readonly untrackedPaths: number;
-  readonly unmergedPaths: number;
-  readonly mergeInProgress: boolean;
-  readonly rebaseInProgress: boolean;
-  readonly rebaseStep: number | null;
-  readonly rebaseTotalSteps: number | null;
-  readonly lastTransitionKind: "checkout" | "reset" | "merge" | "rebase" | null;
-  readonly reflogSubject: string | null;
-}
-
-type SemanticTransitionKind =
-  | "index_update"
-  | "conflict_resolution"
-  | "merge_phase"
-  | "rebase_phase"
-  | "bulk_transition"
-  | "unknown";
-
-type SemanticTransitionPhase =
-  | "started"
-  | "conflicted"
-  | "resolved_waiting_commit"
-  | "continued"
-  | "completed_or_cleared"
-  | null;
-
-function buildConflictResolutionSummary(
-  evidence: SemanticTransitionSummaryEvidence,
-  previousUnmergedPaths: number | null,
-): string {
-  if (evidence.unmergedPaths === 0) {
-    if (previousUnmergedPaths !== null && previousUnmergedPaths > 0) {
-      return `Conflict posture cleared from ${String(previousUnmergedPaths)} conflicted path(s).`;
-    }
-    return "Conflict posture cleared after an explicit conflict-resolution movement.";
-  }
-
-  if (previousUnmergedPaths === null) {
-    return `Conflict posture is active across ${String(evidence.unmergedPaths)} path(s).`;
-  }
-
-  if (previousUnmergedPaths === 0) {
-    return `Conflict posture emerged across ${String(evidence.unmergedPaths)} path(s).`;
-  }
-
-  if (evidence.unmergedPaths < previousUnmergedPaths) {
-    return `Conflict posture is shrinking from ${String(previousUnmergedPaths)} to ${String(evidence.unmergedPaths)} path(s).`;
-  }
-
-  if (evidence.unmergedPaths > previousUnmergedPaths) {
-    return `Conflict posture widened from ${String(previousUnmergedPaths)} to ${String(evidence.unmergedPaths)} path(s).`;
-  }
-
-  return `Conflict posture remains active across ${String(evidence.unmergedPaths)} path(s).`;
-}
-
-function buildBulkTransitionSummary(evidence: SemanticTransitionSummaryEvidence): string {
-  if (
-    evidence.stagedPaths === evidence.totalPaths
-    && evidence.changedPaths === 0
-    && evidence.untrackedPaths === 0
-  ) {
-    return `Bulk staging spans ${String(evidence.totalPaths)} path(s) at the index boundary.`;
-  }
-  if (
-    evidence.changedPaths === evidence.totalPaths
-    && evidence.stagedPaths === 0
-    && evidence.untrackedPaths === 0
-  ) {
-    return `Bulk edit sweep spans ${String(evidence.totalPaths)} unstaged path(s).`;
-  }
-  return `Bulk transition movement spans ${String(evidence.totalPaths)} path(s) with ${String(evidence.stagedPaths)} staged and ${String(evidence.changedPaths)} unstaged changes.`;
-}
-
-export function buildSemanticTransitionSummary(input: {
-  readonly kind: SemanticTransitionKind;
-  readonly evidence: SemanticTransitionSummaryEvidence;
-  readonly phase: SemanticTransitionPhase;
-  readonly previousUnmergedPaths?: number | null;
-}): string {
-  const { kind, evidence, phase, previousUnmergedPaths = null } = input;
-  switch (kind) {
-    case "merge_phase":
-      switch (phase) {
-        case "conflicted":
-          return `Merge is in conflict across ${String(evidence.unmergedPaths)} path(s).`;
-        case "resolved_waiting_commit":
-          return "Merge conflicts are cleared and the merge is waiting for commit/admission.";
-        case "completed_or_cleared":
-          return "Merge transition completed or merge state has cleared.";
-        case "started":
-          return "Merge started and is now inspectable as active repo state.";
-        case "continued":
-          return "Merge progressed and remains active.";
-        default:
-          return "Merge state is active.";
-      }
-    case "rebase_phase":
-      switch (phase) {
-        case "conflicted":
-          return `Rebase is in conflict across ${String(evidence.unmergedPaths)} path(s).`;
-        case "continued":
-          return evidence.rebaseStep !== null && evidence.rebaseTotalSteps !== null
-            ? `Rebase continued at step ${String(evidence.rebaseStep)} of ${String(evidence.rebaseTotalSteps)}.`
-            : "Rebase continued and remains active.";
-        case "completed_or_cleared":
-          return "Rebase transition completed or rebase state has cleared.";
-        case "started":
-          return "Rebase started and is now inspectable as active repo state.";
-        case "resolved_waiting_commit":
-          return "Rebase conflicts are cleared and the rebase is waiting for the next step.";
-        default:
-          return "Rebase state is active.";
-      }
-    case "conflict_resolution":
-      return buildConflictResolutionSummary(evidence, previousUnmergedPaths);
-    case "index_update":
-      return evidence.totalPaths > 1
-        ? `Index/staging boundary changed across ${String(evidence.totalPaths)} path(s).`
-        : "Index/staging boundary changed.";
-    case "bulk_transition":
-      return buildBulkTransitionSummary(evidence);
-    case "unknown":
-      return "Repo/workspace movement is inspectable, but the semantic transition meaning remains unknown.";
-  }
-}

package/src/mcp/server-context.ts

@@ -1,236 +0,0 @@
-import type { JsonObject } from "../contracts/json-object.js";
-import type { CanonicalJsonCodec } from "../adapters/canonical-json.js";
-import type { FileSystem } from "../ports/filesystem.js";
-import type { ProcessRunner } from "../ports/process-runner.js";
-import type { GitClient } from "../ports/git.js";
-import type { WarpContext } from "../warp/context.js";
-import type { ToolContext, ToolDefinition } from "./context.js";
-import type { McpToolResult } from "./receipt.js";
-import type { RunCaptureConfig } from "./run-capture-config.js";
-import type { RuntimeObservabilityState, ToolCallFootprintRegion } from "./runtime-observability.js";
-import type {
-  WorkspaceRouter,
-  WorkspaceExecutionContext,
-} from "./workspace-router.js";
-import type { DaemonControlPlane } from "./daemon-control-plane.js";
-import type { DaemonRepoOverview } from "./daemon-repos.js";
-import type { DaemonJobScheduler } from "./daemon-job-scheduler.js";
-import type { DaemonWorkerPool } from "./daemon-worker-pool.js";
-import type { PersistentMonitorRuntime } from "./persistent-monitor-runtime.js";
-import type { DaemonRuntimeDescriptor } from "./daemon-control-plane.js";
-import { mergeRepoConcurrencySummaryWithLiveSessions } from "./repo-concurrency.js";
-
-/** Dependencies injected by the composition root to build a ToolContext. */
-export interface ToolContextDeps {
-  readonly workspaceRouter: WorkspaceRouter;
-  readonly fs: FileSystem;
-  readonly codec: CanonicalJsonCodec;
-  readonly processRunner: ProcessRunner;
-  readonly git: GitClient;
-  readonly runCapture: RunCaptureConfig;
-  readonly observability: RuntimeObservabilityState;
-  readonly daemonControlPlane: DaemonControlPlane | null;
-  readonly daemonRepoOverview: DaemonRepoOverview | null;
-  readonly daemonScheduler: DaemonJobScheduler | null;
-  readonly daemonWorkerPool: DaemonWorkerPool | null;
-  readonly monitorRuntime: PersistentMonitorRuntime | null;
-  readonly daemonRuntime: () => DaemonRuntimeDescriptor;
-  readonly getActiveExecutionContext: () => WorkspaceExecutionContext | null;
-  readonly respond: (tool: ToolDefinition["name"], data: JsonObject) => McpToolResult;
-  readonly recordFootprint: (entry: {
-    readonly paths?: readonly string[];
-    readonly symbols?: readonly string[];
-    readonly regions?: readonly ToolCallFootprintRegion[];
-  }) => void;
-}
-
-/**
- * Builds the ToolContext object with lazy property getters that delegate
- * to the active WorkspaceExecutionContext (when inside a daemon-scheduled
- * tool call) or fall back to the WorkspaceRouter defaults.
- */
-export function buildToolContext(deps: ToolContextDeps): ToolContext {
-  const {
-    workspaceRouter,
-    daemonControlPlane,
-    daemonRepoOverview,
-    daemonScheduler,
-    daemonWorkerPool,
-    monitorRuntime,
-    daemonRuntime,
-    getActiveExecutionContext,
-    respond,
-  } = deps;
-
-  return {
-    get projectRoot(): string {
-      return getActiveExecutionContext()?.projectRoot ?? workspaceRouter.getProjectRoot();
-    },
-    get graftDir(): string {
-      return getActiveExecutionContext()?.graftDir ?? workspaceRouter.graftDir;
-    },
-    get graftignorePatterns(): readonly string[] {
-      return getActiveExecutionContext()?.graftignorePatterns ?? workspaceRouter.getGraftignorePatterns();
-    },
-    get governor() {
-      return getActiveExecutionContext()?.governor ?? workspaceRouter.governor;
-    },
-    get cache() {
-      return getActiveExecutionContext()?.cache ?? workspaceRouter.cache;
-    },
-    get metrics() {
-      return getActiveExecutionContext()?.metrics ?? workspaceRouter.metrics;
-    },
-    respond,
-    recordFootprint: deps.recordFootprint,
-    resolvePath(relative: string): string {
-      return getActiveExecutionContext()?.resolvePath(relative) ?? workspaceRouter.getPathResolver()(relative);
-    },
-    fs: deps.fs,
-    codec: deps.codec,
-    process: deps.processRunner,
-    git: deps.git,
-    runCapture: deps.runCapture,
-    observability: deps.observability,
-    getWarp(): Promise<WarpContext> {
-      return getActiveExecutionContext()?.getWarp() ?? workspaceRouter.getWarp();
-    },
-    getRepoState() {
-      return getActiveExecutionContext()?.repoState.getState() ?? workspaceRouter.getRepoState();
-    },
-    getCausalContext() {
-      return getActiveExecutionContext()?.getCausalContext() ?? workspaceRouter.captureExecutionContext().getCausalContext();
-    },
-    getWorkspaceOverlayFooting() {
-      return workspaceRouter.getWorkspaceOverlayFooting();
-    },
-    getPersistedLocalHistorySummary() {
-      return workspaceRouter.getPersistedLocalHistorySummary();
-    },
-    getPersistedLocalActivityWindow(limit) {
-      return workspaceRouter.getPersistedLocalActivityWindow(limit);
-    },
-    getRepoConcurrencySummary() {
-      return (async () => {
-        const summary = await workspaceRouter.getRepoConcurrencySummary();
-        if (summary === null || daemonControlPlane === null) {
-          return summary;
-        }
-        const status = workspaceRouter.getStatus();
-        if (status.bindState !== "bound" || status.repoId === null || status.worktreeId === null) {
-          return summary;
-        }
-        const causalContext = workspaceRouter.captureExecutionContext().getCausalContext();
-        return mergeRepoConcurrencySummaryWithLiveSessions({
-          currentSummary: summary,
-          currentRepoId: status.repoId,
-          currentWorktreeId: status.worktreeId,
-          currentCheckoutEpochId: causalContext.checkoutEpochId,
-          sessions: daemonControlPlane.listTransports(),
-        });
-      })();
-    },
-    declareCausalAttach(request) {
-      return workspaceRouter.declareAttach(request);
-    },
-    getWorkspaceStatus() {
-      return getActiveExecutionContext()?.status ?? workspaceRouter.getStatus();
-    },
-    bindWorkspace(request, actionName) {
-      return workspaceRouter.bind(request, actionName);
-    },
-    rebindWorkspace(request, actionName) {
-      return workspaceRouter.rebind(request, actionName);
-    },
-    getDaemonStatus() {
-      if (daemonControlPlane === null) {
-        throw new Error("daemon_status is only available in daemon mode");
-      }
-      if (daemonScheduler === null) {
-        throw new Error("daemon_status is only available in daemon mode");
-      }
-      if (daemonWorkerPool === null) {
-        throw new Error("daemon_status is only available in daemon mode");
-      }
-      return Promise.resolve(daemonControlPlane.getStatus(
-        daemonRuntime(),
-        monitorRuntime?.getCounts(),
-        daemonScheduler.getCounts(),
-        daemonWorkerPool.getCounts(),
-      ));
-    },
-    listDaemonRepos(filter) {
-      if (daemonRepoOverview === null) {
-        throw new Error("daemon_repos is only available in daemon mode");
-      }
-      return daemonRepoOverview.list(filter);
-    },
-    listDaemonSessions() {
-      if (daemonControlPlane === null) {
-        throw new Error("daemon_sessions is only available in daemon mode");
-      }
-      return Promise.resolve(daemonControlPlane.listTransports());
-    },
-    listDaemonMonitors() {
-      if (monitorRuntime === null) {
-        throw new Error("daemon_monitors is only available in daemon mode");
-      }
-      return monitorRuntime.listStatuses();
-    },
-    startMonitor(request) {
-      if (monitorRuntime === null) {
-        throw new Error("monitor_start is only available in daemon mode");
-      }
-      return monitorRuntime.startMonitor(request);
-    },
-    pauseMonitor(request) {
-      if (monitorRuntime === null) {
-        throw new Error("monitor_pause is only available in daemon mode");
-      }
-      return monitorRuntime.pauseMonitor(request);
-    },
-    resumeMonitor(request) {
-      if (monitorRuntime === null) {
-        throw new Error("monitor_resume is only available in daemon mode");
-      }
-      return monitorRuntime.resumeMonitor(request);
-    },
-    nudgeMonitor(request) {
-      if (monitorRuntime === null) {
-        return Promise.resolve({
-          ok: false,
-          action: "nudge",
-          created: false,
-          changed: false,
-          errorCode: "no_daemon",
-          error: "Monitor runtime is not available.",
-        });
-      }
-      return monitorRuntime.nudgeMonitor(request);
-    },
-    stopMonitor(request) {
-      if (monitorRuntime === null) {
-        throw new Error("monitor_stop is only available in daemon mode");
-      }
-      return monitorRuntime.stopMonitor(request);
-    },
-    listWorkspaceAuthorizations() {
-      if (daemonControlPlane === null) {
-        throw new Error("workspace_authorizations is only available in daemon mode");
-      }
-      return daemonControlPlane.listAuthorizedWorkspaces();
-    },
-    authorizeWorkspace(request) {
-      if (daemonControlPlane === null) {
-        throw new Error("workspace_authorize is only available in daemon mode");
-      }
-      return daemonControlPlane.authorizeWorkspace(request);
-    },
-    revokeWorkspace(request) {
-      if (daemonControlPlane === null) {
-        throw new Error("workspace_revoke is only available in daemon mode");
-      }
-      return daemonControlPlane.revokeWorkspace(request);
-    },
-  };
-}