@flyingrobots/graft 0.5.0 → 0.6.0

package/src/mcp/repo-concurrency.ts

@@ -29,6 +29,13 @@ export interface RepoConcurrencySummary {
   readonly observedActorCount: number;
   readonly overlappingPathCount: number;
   readonly summary: string;
+  readonly daemonSessionLiveness?: RepoConcurrencyDaemonSessionLiveness;
+}
+
+export interface RepoConcurrencyDaemonSessionLiveness {
+  readonly idleTimeoutMs: number;
+  readonly liveSessionCount: number;
+  readonly staleSessionCount: number;
 }
 
 interface RepoConcurrencyInput {
@@ -42,8 +49,11 @@ export interface RepoConcurrencyLiveSession {
   readonly worktreeId: string | null;
   readonly causalSessionId: string | null;
   readonly checkoutEpochId: string | null;
+  readonly lastActivityAt: string;
 }
 
+export const DEFAULT_DAEMON_SESSION_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+
 function countOverlapPaths(touches: readonly RepoConcurrencyTouch[]): number {
   const contributorsByPath = new Map<string, Set<string>>();
   for (const touch of touches) {
@@ -97,6 +107,52 @@ function withObservedCounts(
   };
 }
 
+function formatDurationMs(durationMs: number): string {
+  if (durationMs % 60000 === 0) {
+    const minutes = durationMs / 60000;
+    return `${String(minutes)} minute${minutes === 1 ? "" : "s"}`;
+  }
+  if (durationMs % 1000 === 0) {
+    const seconds = durationMs / 1000;
+    return `${String(seconds)} second${seconds === 1 ? "" : "s"}`;
+  }
+  return `${String(durationMs)} ms`;
+}
+
+function appendStaleDaemonSessionSummary(
+  summary: string,
+  liveness: RepoConcurrencyDaemonSessionLiveness,
+): string {
+  if (liveness.staleSessionCount === 0) {
+    return summary;
+  }
+  const noun = liveness.staleSessionCount === 1 ? "session" : "sessions";
+  return `${summary} Excluded ${String(liveness.staleSessionCount)} stale daemon ${noun} idle for longer than ${formatDurationMs(liveness.idleTimeoutMs)}.`;
+}
+
+function withDaemonSessionLiveness(
+  summary: RepoConcurrencySummary,
+  liveness: RepoConcurrencyDaemonSessionLiveness,
+): RepoConcurrencySummary {
+  return {
+    ...summary,
+    summary: appendStaleDaemonSessionSummary(summary.summary, liveness),
+    daemonSessionLiveness: liveness,
+  };
+}
+
+function isStaleDaemonSession(
+  session: RepoConcurrencyLiveSession,
+  nowMs: number,
+  idleTimeoutMs: number,
+): boolean {
+  const lastActivityMs = Date.parse(session.lastActivityAt);
+  if (!Number.isFinite(lastActivityMs)) {
+    return true;
+  }
+  return nowMs - lastActivityMs > idleTimeoutMs;
+}
+
 export function deriveRepoConcurrencySummary(input: RepoConcurrencyInput): RepoConcurrencySummary {
   const activeHistories = input.histories.filter((history) => history.active);
   const current = activeHistories.find((history) => history.worktreeId === input.currentWorktreeId)
@@ -206,28 +262,46 @@ export function mergeRepoConcurrencySummaryWithLiveSessions(input: {
   readonly currentWorktreeId: string;
   readonly currentCheckoutEpochId: string | null;
   readonly sessions: readonly RepoConcurrencyLiveSession[];
+  readonly nowMs?: number;
+  readonly sessionIdleTimeoutMs?: number;
 }): RepoConcurrencySummary {
-  const liveRepoSessions = input.sessions.filter((session) =>
+  const repoSessions = input.sessions.filter((session) =>
     session.bindState === "bound" &&
     session.repoId === input.currentRepoId &&
     session.worktreeId !== null
   );
 
-  if (liveRepoSessions.length === 0) {
+  if (repoSessions.length === 0) {
     return input.currentSummary;
   }
 
+  const nowMs = input.nowMs ?? Date.now();
+  const idleTimeoutMs = input.sessionIdleTimeoutMs ?? DEFAULT_DAEMON_SESSION_IDLE_TIMEOUT_MS;
+  const liveRepoSessions = repoSessions.filter((session) => !isStaleDaemonSession(session, nowMs, idleTimeoutMs));
+  const liveness: RepoConcurrencyDaemonSessionLiveness = {
+    idleTimeoutMs,
+    liveSessionCount: liveRepoSessions.length,
+    staleSessionCount: repoSessions.length - liveRepoSessions.length,
+  };
+
+  if (liveRepoSessions.length === 0) {
+    return withDaemonSessionLiveness(input.currentSummary, liveness);
+  }
+
   const observedWorktreeCount = new Set(liveRepoSessions.map((session) => session.worktreeId)).size;
   const observedCausalSessionCount = new Set(
     liveRepoSessions
       .map((session) => session.causalSessionId)
       .filter((sessionId): sessionId is string => sessionId !== null),
   ).size;
-  const summaryWithCounts = withObservedCounts(input.currentSummary, {
-    observedWorktreeCount: Math.max(1, observedWorktreeCount),
-    observedCausalSessionCount,
-    observedActorCount: input.currentSummary.observedActorCount,
-  });
+  const summaryWithCounts = withDaemonSessionLiveness(
+    withObservedCounts(input.currentSummary, {
+      observedWorktreeCount: Math.max(1, observedWorktreeCount),
+      observedCausalSessionCount,
+      observedActorCount: input.currentSummary.observedActorCount,
+    }),
+    liveness,
+  );
 
   const currentWorktreeSessions = liveRepoSessions.filter((session) => session.worktreeId === input.currentWorktreeId);
   const otherWorktreeSessions = liveRepoSessions.filter((session) => session.worktreeId !== input.currentWorktreeId);

package/src/mcp/repo-overview/filter.ts

@@ -0,0 +1,44 @@
+import type { AuthorizedWorkspaceRecord } from "../daemon-control-plane.js";
+import type { DaemonRepoFilter, DaemonRepoListView, DaemonRepoView } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Filter normalization
+// ---------------------------------------------------------------------------
+
+export function normalizeFilter(filter: DaemonRepoFilter): DaemonRepoFilter {
+  const next: { repoId?: string; cwd?: string } = {};
+  if (typeof filter.repoId === "string" && filter.repoId.trim().length > 0) {
+    next.repoId = filter.repoId.trim();
+  }
+  if (typeof filter.cwd === "string" && filter.cwd.trim().length > 0) {
+    next.cwd = filter.cwd.trim();
+  }
+  return next;
+}
+
+// ---------------------------------------------------------------------------
+// Workspace sorting
+// ---------------------------------------------------------------------------
+
+export function sortAuthorizedWorkspaces(
+  records: readonly AuthorizedWorkspaceRecord[],
+): readonly AuthorizedWorkspaceRecord[] {
+  return [...records].sort((left, right) => left.worktreeRoot.localeCompare(right.worktreeRoot));
+}
+
+// ---------------------------------------------------------------------------
+// Result builders
+// ---------------------------------------------------------------------------
+
+export function buildResult(
+  filter: DaemonRepoFilter,
+  repos: readonly DaemonRepoView[],
+): DaemonRepoListView {
+  if (Object.keys(filter).length === 0) {
+    return { repos };
+  }
+  return {
+    repos,
+    filter,
+  };
+}

package/src/mcp/repo-overview/types.ts

@@ -0,0 +1,63 @@
+import type { DaemonControlPlane } from "../daemon-control-plane.js";
+import type {
+  MonitorHealth,
+  MonitorLifecycleState,
+  MonitorWorkerKind,
+  PersistentMonitorRuntime,
+} from "../persistent-monitor-runtime.js";
+
+// ---------------------------------------------------------------------------
+// Filter
+// ---------------------------------------------------------------------------
+
+export interface DaemonRepoFilter {
+  readonly repoId?: string | undefined;
+  readonly cwd?: string | undefined;
+}
+
+// ---------------------------------------------------------------------------
+// View projections
+// ---------------------------------------------------------------------------
+
+export interface DaemonRepoWorktreeView {
+  readonly worktreeId: string;
+  readonly worktreeRoot: string;
+  readonly activeSessions: number;
+  readonly lastBoundAt: string | null;
+}
+
+export interface DaemonRepoMonitorView {
+  readonly workerKind: MonitorWorkerKind;
+  readonly lifecycleState: MonitorLifecycleState;
+  readonly health: MonitorHealth;
+  readonly lastTickAt: string | null;
+  readonly lastSuccessAt: string | null;
+  readonly lastError: string | null;
+}
+
+export interface DaemonRepoView {
+  readonly repoId: string;
+  readonly gitCommonDir: string;
+  readonly authorizedWorkspaces: number;
+  readonly boundSessions: number;
+  readonly activeWorktrees: number;
+  readonly backlogCommits: number;
+  readonly lastBoundAt: string | null;
+  readonly lastActivityAt: string | null;
+  readonly monitor: DaemonRepoMonitorView | null;
+  readonly worktrees: readonly DaemonRepoWorktreeView[];
+}
+
+export interface DaemonRepoListView {
+  readonly repos: readonly DaemonRepoView[];
+  readonly filter?: DaemonRepoFilter | undefined;
+}
+
+// ---------------------------------------------------------------------------
+// Options
+// ---------------------------------------------------------------------------
+
+export interface DaemonRepoOverviewOptions {
+  readonly controlPlane: DaemonControlPlane;
+  readonly monitorRuntime: PersistentMonitorRuntime;
+}

package/src/mcp/repo-overview/view-projection.ts

@@ -0,0 +1,90 @@
+import type { AuthorizedWorkspaceRecord, DaemonSessionView } from "../daemon-control-plane.js";
+import type { MonitorStatusView } from "../persistent-monitor-runtime.js";
+import type { DaemonRepoMonitorView, DaemonRepoView, DaemonRepoWorktreeView } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Timestamp helpers
+// ---------------------------------------------------------------------------
+
+export function maxIsoTimestamp(values: readonly (string | null | undefined)[]): string | null {
+  let latest: string | null = null;
+  for (const value of values) {
+    if (value === undefined || value === null || value.length === 0) continue;
+    if (latest === null || value.localeCompare(latest) > 0) {
+      latest = value;
+    }
+  }
+  return latest;
+}
+
+// ---------------------------------------------------------------------------
+// Worktree view projection
+// ---------------------------------------------------------------------------
+
+export function toWorktreeView(
+  workspace: AuthorizedWorkspaceRecord,
+  repoSessions: readonly DaemonSessionView[],
+): DaemonRepoWorktreeView {
+  return {
+    worktreeId: workspace.worktreeId,
+    worktreeRoot: workspace.worktreeRoot,
+    activeSessions: repoSessions.filter((session) => {
+      return session.bindState === "bound" && session.worktreeId === workspace.worktreeId;
+    }).length,
+    lastBoundAt: workspace.lastBoundAt,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Monitor view projection
+// ---------------------------------------------------------------------------
+
+export function toMonitorView(monitor: MonitorStatusView): DaemonRepoMonitorView {
+  return {
+    workerKind: monitor.workerKind,
+    lifecycleState: monitor.lifecycleState,
+    health: monitor.health,
+    lastTickAt: monitor.lastTickAt,
+    lastSuccessAt: monitor.lastSuccessAt,
+    lastError: monitor.lastError,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Repo view assembly
+// ---------------------------------------------------------------------------
+
+export function toRepoView(
+  repoId: string,
+  sortedWorkspaces: readonly AuthorizedWorkspaceRecord[],
+  repoSessions: readonly DaemonSessionView[],
+  monitor: MonitorStatusView | null,
+): DaemonRepoView {
+  const firstWorkspace = sortedWorkspaces[0];
+  if (firstWorkspace === undefined) {
+    throw new Error(`DaemonRepoOverview: missing workspace for repo ${repoId}`);
+  }
+  const worktrees = sortedWorkspaces.map((workspace) => toWorktreeView(workspace, repoSessions));
+  const boundSessions = repoSessions.filter((session) => session.bindState === "bound").length;
+  const lastBoundAt = maxIsoTimestamp(sortedWorkspaces.map((workspace) => workspace.lastBoundAt));
+  const lastActivityAt = maxIsoTimestamp([
+    ...sortedWorkspaces.map((workspace) => workspace.authorizedAt),
+    ...sortedWorkspaces.map((workspace) => workspace.lastBoundAt),
+    ...repoSessions.map((session) => session.lastActivityAt),
+    ...(monitor === null
+      ? []
+      : [monitor.lastStartedAt, monitor.lastTickAt, monitor.lastSuccessAt]),
+  ]);
+  return {
+    repoId,
+    gitCommonDir: firstWorkspace.gitCommonDir,
+    authorizedWorkspaces: sortedWorkspaces.length,
+    boundSessions,
+    activeWorktrees: worktrees.filter((worktree) => worktree.activeSessions > 0).length,
+    backlogCommits: monitor?.backlogCommits ?? 0,
+    lastBoundAt,
+    lastActivityAt,
+    monitor: monitor === null ? null : toMonitorView(monitor),
+    worktrees,
+  };
+}

package/src/mcp/repo-state-git.ts

@@ -0,0 +1,247 @@
+import type { GitClient } from "../ports/git.js";
+import type { FileSystem } from "../ports/filesystem.js";
+import type { HeadReflogEntry, RebaseProgressState, RepoSnapshot } from "./repo-state-types.js";
+
+export async function git(gitClient: GitClient, args: readonly string[], cwd: string): Promise<string> {
+  const result = await gitClient.run({ args, cwd });
+  if (result.error !== undefined || result.status !== 0) {
+    throw result.error ?? new Error(result.stderr.trim() || `git exited with status ${String(result.status)}`);
+  }
+  return result.stdout;
+}
+
+export async function readGit(gitClient: GitClient, args: readonly string[], cwd: string): Promise<string | null> {
+  try {
+    const value = (await git(gitClient, args, cwd)).trim();
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+async function readGitPorcelain(gitClient: GitClient, args: readonly string[], cwd: string): Promise<string | null> {
+  try {
+    const value = (await git(gitClient, args, cwd)).replace(/\r?\n$/, "");
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+async function readGitLines(gitClient: GitClient, args: readonly string[], cwd: string): Promise<string[]> {
+  const value = await readGitPorcelain(gitClient, args, cwd);
+  return value === null ? [] : value.split("\n");
+}
+
+async function readGitPathText(
+  fs: FileSystem,
+  gitClient: GitClient,
+  cwd: string,
+  gitPath: string,
+): Promise<string | null> {
+  const resolvedPath = await readGit(gitClient, ["rev-parse", "--path-format=absolute", "--git-path", gitPath], cwd);
+  if (resolvedPath === null) return null;
+
+  try {
+    const content = await fs.readFile(resolvedPath, "utf-8");
+    const value = content.trim();
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+function parseOptionalInt(value: string | null): number | null {
+  if (value === null) return null;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function countStatusLines(statusLines: readonly string[]): {
+  stagedPaths: number;
+  changedPaths: number;
+  untrackedPaths: number;
+} {
+  let stagedPaths = 0;
+  let changedPaths = 0;
+  let untrackedPaths = 0;
+
+  for (const statusLine of statusLines) {
+    const x = statusLine[0] ?? " ";
+    const y = statusLine[1] ?? " ";
+    if (x === "?" && y === "?") {
+      untrackedPaths++;
+      continue;
+    }
+    if (x !== " ") stagedPaths++;
+    if (y !== " ") changedPaths++;
+  }
+
+  return { stagedPaths, changedPaths, untrackedPaths };
+}
+
+async function countUnmergedPaths(gitClient: GitClient, cwd: string): Promise<number> {
+  const paths = await readGitLines(gitClient, ["diff", "--name-only", "--diff-filter=U", "--"], cwd);
+  return new Set(paths.filter((value) => value.length > 0)).size;
+}
+
+function mergeStatusLines(
+  stagedLines: readonly string[],
+  changedLines: readonly string[],
+  untrackedLines: readonly string[],
+): readonly string[] {
+  const merged = new Map<string, { x: string; y: string }>();
+
+  for (const line of stagedLines) {
+    const parts = line.split("\t");
+    const rawStatus = parts[0] ?? "";
+    const filePath = parts.at(-1) ?? "";
+    if (filePath.length === 0) continue;
+    const existing = merged.get(filePath) ?? { x: " ", y: " " };
+    existing.x = rawStatus[0] ?? "M";
+    merged.set(filePath, existing);
+  }
+
+  for (const line of changedLines) {
+    const parts = line.split("\t");
+    const rawStatus = parts[0] ?? "";
+    const filePath = parts.at(-1) ?? "";
+    if (filePath.length === 0) continue;
+    const existing = merged.get(filePath) ?? { x: " ", y: " " };
+    existing.y = rawStatus[0] ?? "M";
+    merged.set(filePath, existing);
+  }
+
+  for (const filePath of untrackedLines) {
+    if (filePath.length === 0) continue;
+    merged.set(filePath, { x: "?", y: "?" });
+  }
+
+  return [...merged.entries()]
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([filePath, status]) => `${status.x}${status.y} ${filePath}`);
+}
+
+async function readParentShas(gitClient: GitClient, cwd: string, headSha: string | null): Promise<readonly string[]> {
+  if (headSha === null) return [];
+  const raw = await readGit(gitClient, ["show", "-s", "--format=%P", headSha], cwd);
+  if (raw === null || raw.trim().length === 0) return [];
+  return raw.trim().split(/\s+/).filter((sha) => sha.length > 0);
+}
+
+async function readMergeInProgress(
+  fs: FileSystem,
+  gitClient: GitClient,
+  cwd: string,
+): Promise<boolean> {
+  return (await readGitPathText(fs, gitClient, cwd, "MERGE_HEAD")) !== null;
+}
+
+async function readRebaseProgressState(
+  fs: FileSystem,
+  gitClient: GitClient,
+  cwd: string,
+): Promise<RebaseProgressState> {
+  const mergeHead = await readGitPathText(fs, gitClient, cwd, "rebase-merge/head-name");
+  if (mergeHead !== null) {
+    return {
+      inProgress: true,
+      step: parseOptionalInt(await readGitPathText(fs, gitClient, cwd, "rebase-merge/msgnum")),
+      total: parseOptionalInt(await readGitPathText(fs, gitClient, cwd, "rebase-merge/end")),
+    };
+  }
+
+  const applyHead = await readGitPathText(fs, gitClient, cwd, "rebase-apply/head-name");
+  if (applyHead !== null) {
+    return {
+      inProgress: true,
+      step: parseOptionalInt(await readGitPathText(fs, gitClient, cwd, "rebase-apply/next")),
+      total: parseOptionalInt(await readGitPathText(fs, gitClient, cwd, "rebase-apply/last")),
+    };
+  }
+
+  const rebaseHead = await readGitPathText(fs, gitClient, cwd, "REBASE_HEAD");
+  return {
+    inProgress: rebaseHead !== null,
+    step: null,
+    total: null,
+  };
+}
+
+async function readHeadReflog(fs: FileSystem, gitClient: GitClient, cwd: string): Promise<HeadReflogEntry | null> {
+  const reflogPath = await readGit(gitClient, ["rev-parse", "--path-format=absolute", "--git-path", "logs/HEAD"], cwd);
+  if (reflogPath === null) return null;
+
+  try {
+    const content = await fs.readFile(reflogPath, "utf-8");
+    const lines = content.split(/\r?\n/).map((line) => line.trimEnd());
+    let raw: string | null = null;
+    for (let index = lines.length - 1; index >= 0; index--) {
+      const line = lines[index];
+      if (line !== undefined && line.length > 0) {
+        raw = line;
+        break;
+      }
+    }
+    if (raw === null) return null;
+    const [meta = "", subject = ""] = raw.split("\t");
+    const tokens = meta.split(" ");
+    const previousSha = tokens[0] ?? null;
+    const nextSha = tokens[1] ?? null;
+    const timestampToken = tokens.length >= 2 ? tokens[tokens.length - 2] : undefined;
+    const timestampSec = timestampToken !== undefined ? Number.parseInt(timestampToken, 10) : Number.NaN;
+
+    return {
+      raw,
+      previousSha: previousSha !== null && /^[0-9a-f]{40}$/i.test(previousSha) ? previousSha : null,
+      nextSha: nextSha !== null && /^[0-9a-f]{40}$/i.test(nextSha) ? nextSha : null,
+      timestampSec: Number.isFinite(timestampSec) ? timestampSec : null,
+      subject,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function isAncestor(
+  gitClient: GitClient,
+  cwd: string,
+  possibleAncestor: string | null,
+  possibleDescendant: string | null,
+): Promise<boolean> {
+  if (possibleAncestor === null || possibleDescendant === null) {
+    return false;
+  }
+  const result = await gitClient.run({
+    args: ["merge-base", "--is-ancestor", possibleAncestor, possibleDescendant],
+    cwd,
+  });
+  return result.status === 0;
+}
+
+export async function captureSnapshot(cwd: string, fs: FileSystem, gitClient: GitClient): Promise<RepoSnapshot> {
+  const headSha = await readGit(gitClient, ["rev-parse", "HEAD"], cwd);
+  const statusLines = mergeStatusLines(
+    headSha === null ? [] : await readGitLines(gitClient, ["diff-index", "--cached", "--find-renames", "--name-status", headSha, "--"], cwd),
+    await readGitLines(gitClient, ["diff-files", "--find-renames", "--name-status", "--"], cwd),
+    await readGitLines(gitClient, ["ls-files", "--others", "--exclude-standard"], cwd),
+  );
+  const counts = countStatusLines(statusLines);
+  const unmergedPaths = await countUnmergedPaths(gitClient, cwd);
+  const mergeInProgress = await readMergeInProgress(fs, gitClient, cwd);
+  const rebase = await readRebaseProgressState(fs, gitClient, cwd);
+
+  return {
+    headRef: await readGit(gitClient, ["symbolic-ref", "--quiet", "--short", "HEAD"], cwd),
+    headSha,
+    parentShas: await readParentShas(gitClient, cwd, headSha),
+    observedAt: new Date().toISOString(),
+    statusLines,
+    dirty: statusLines.length > 0,
+    ...counts,
+    unmergedPaths,
+    mergeInProgress,
+    rebase,
+    headReflog: await readHeadReflog(fs, gitClient, cwd),
+  };
+}