@h-rig/server 0.0.6-alpha.0

package/dist/src/inspector/provider-session.js

@@ -0,0 +1,65 @@
+// @bun
+// packages/server/src/inspector/provider-session.ts
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))];
+}
+function withSupport(defaultValue, support, key) {
+  return typeof support?.[key] === "boolean" ? Boolean(support[key]) : defaultValue;
+}
+function normalizeProviderSession(run) {
+  const sessionLogPaths = uniqueStrings([run.sessionLogPath]);
+  const artifactRoots = uniqueStrings([run.artifactRoot]);
+  const eventSources = uniqueStrings([run.source, ...run.rawSourceKinds, run.sessionPath ? "session-file" : null]);
+  const capabilityHints = uniqueStrings([
+    sessionLogPaths.length > 0 ? "logs" : null,
+    artifactRoots.length > 0 ? "artifacts" : null,
+    run.worktreePath ? "workspace" : null,
+    run.conflictState !== "none" ? "conflict" : null,
+    run.threadId ? "thread" : null
+  ]);
+  const observabilityConfidence = sessionLogPaths.length > 0 && artifactRoots.length > 0 && run.threadId ? "high" : sessionLogPaths.length > 0 || artifactRoots.length > 0 || Boolean(run.threadId) ? "medium" : "low";
+  return {
+    provider: run.provider,
+    runId: run.runId,
+    taskId: run.taskId,
+    workspaceId: run.workspaceId,
+    workspaceDir: run.worktreePath,
+    runtimeAdapter: run.runtimeAdapter,
+    status: run.status,
+    startedAt: run.startedAt,
+    updatedAt: run.updatedAt,
+    completedAt: run.completedAt,
+    threadId: run.threadId,
+    sessionLogPaths,
+    artifactRoots,
+    eventSources,
+    observabilityConfidence,
+    rawSourceKinds: [...run.rawSourceKinds],
+    capabilityHints
+  };
+}
+function deriveInspectorCapabilitySet(session, support = {}) {
+  return {
+    discoverRuns: withSupport(true, support, "discoverRuns"),
+    inspectRuns: withSupport(true, support, "inspectRuns"),
+    readLogs: session.sessionLogPaths.length > 0 && withSupport(true, support, "readLogs"),
+    readArtifacts: session.artifactRoots.length > 0 && withSupport(true, support, "readArtifacts"),
+    callServerApis: withSupport(true, support, "callServerApis"),
+    interruptRuns: withSupport(false, support, "interruptRuns"),
+    stopRuns: withSupport(false, support, "stopRuns"),
+    resumeRuns: withSupport(false, support, "resumeRuns"),
+    relaunchRuns: withSupport(false, support, "relaunchRuns"),
+    patchRepo: session.workspaceDir !== null && withSupport(true, support, "patchRepo"),
+    patchHarness: session.workspaceDir !== null && withSupport(true, support, "patchHarness"),
+    createTasks: withSupport(false, support, "createTasks"),
+    runReviewerAgents: withSupport(false, support, "runReviewerAgents"),
+    provisionSkills: withSupport(true, support, "provisionSkills"),
+    scanUpstream: withSupport(false, support, "scanUpstream"),
+    writeJournal: withSupport(true, support, "writeJournal"),
+    spawnSpecialists: withSupport(false, support, "spawnSpecialists")
+  };
+}
+export {
+  normalizeProviderSession,
+  deriveInspectorCapabilitySet
+};

package/dist/src/inspector/reconcile.js

@@ -0,0 +1,118 @@
+// @bun
+// packages/server/src/inspector/reconcile.ts
+function decisionTypeForStatus(status) {
+  switch (status) {
+    case "failed":
+      return "investigate-failure";
+    case "stopped":
+      return "inspect-stop";
+    default:
+      return null;
+  }
+}
+function reconcileInspectorRuns(options) {
+  const now = options.now ?? (() => new Date().toISOString());
+  let observedCount = 0;
+  let decisionCount = 0;
+  let actionCount = 0;
+  for (const run of options.runs) {
+    options.journal.upsertRun({
+      runId: run.runId,
+      workspaceId: run.workspaceId,
+      taskId: run.taskId,
+      runtimeAdapter: run.runtimeAdapter,
+      provider: run.provider,
+      status: run.status,
+      conflictState: run.conflictState,
+      conflictSummary: run.conflictSummary,
+      source: run.source,
+      title: run.title,
+      startedAt: run.startedAt,
+      updatedAt: run.updatedAt,
+      completedAt: run.completedAt
+    });
+    const observation = options.journal.appendObservation({
+      id: `observation:${run.runId}:${options.reason}:${run.updatedAt}`,
+      runId: run.runId,
+      dedupeKey: `run:${run.runId}:status:${run.status}:updated:${run.updatedAt}`,
+      kind: "run.observed",
+      severity: run.status === "failed" ? "warn" : "info",
+      source: run.source,
+      summary: `Observed run ${run.title}`,
+      details: {
+        reason: options.reason,
+        status: run.status,
+        provider: run.provider,
+        runtimeAdapter: run.runtimeAdapter,
+        conflictState: run.conflictState,
+        rawSourceKinds: run.rawSourceKinds
+      },
+      createdAt: now()
+    });
+    if (observation.ok && observation.changed) {
+      observedCount += 1;
+    }
+    const action = options.journal.appendAction({
+      id: `action:${run.runId}:${options.reason}:${run.updatedAt}`,
+      runId: run.runId,
+      dedupeKey: `action:${run.runId}:observe:${run.updatedAt}`,
+      actionType: "observe",
+      status: "completed",
+      target: `run:${run.runId}`,
+      input: { reason: options.reason },
+      result: { status: run.status },
+      startedAt: now(),
+      completedAt: now()
+    });
+    if (action.ok && action.changed) {
+      actionCount += 1;
+    }
+    const decisionType = decisionTypeForStatus(run.status);
+    if (decisionType) {
+      const decision = options.journal.appendDecision({
+        id: `decision:${run.runId}:${decisionType}:${run.updatedAt}`,
+        runId: run.runId,
+        dedupeKey: `decision:${run.runId}:${decisionType}:${run.updatedAt}`,
+        decisionType,
+        summary: `Investigate ${run.title}`,
+        rationale: `Run status ${run.status} requires inspector attention.`,
+        details: {
+          reason: options.reason,
+          status: run.status
+        },
+        createdAt: now()
+      });
+      if (decision.ok && decision.changed) {
+        decisionCount += 1;
+      }
+    }
+    if (run.conflictState !== "none") {
+      const conflictDecision = options.journal.appendDecision({
+        id: `decision:${run.runId}:conflict:${run.updatedAt}`,
+        runId: run.runId,
+        dedupeKey: `decision:${run.runId}:conflict:${run.updatedAt}`,
+        decisionType: "inspect-conflict",
+        summary: `Resolve ${run.title} observation conflict`,
+        rationale: run.conflictSummary ?? "Observed run surfaces disagree and require inspector review.",
+        details: {
+          reason: options.reason,
+          conflictState: run.conflictState,
+          conflictSummary: run.conflictSummary
+        },
+        createdAt: now()
+      });
+      if (conflictDecision.ok && conflictDecision.changed) {
+        decisionCount += 1;
+      }
+    }
+  }
+  return {
+    discoveredCount: options.runs.length,
+    observedCount,
+    decisionCount,
+    actionCount
+  };
+}
+export {
+  reconcileInspectorRuns
+};

package/dist/src/inspector/review.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/server/src/inspector/review.ts
+function buildLocalReviewRequest(options) {
+  return {
+    reviewerType: "local-reviewer",
+    runId: options.runId,
+    taskId: options.taskId,
+    focus: options.focus
+  };
+}
+export {
+  buildLocalReviewRequest
+};