@jmoyers/harness 0.1.10 → 0.1.20

package/src/services/runtime-nim-tool-bridge.ts

@@ -0,0 +1,141 @@
+import type { NimToolDefinition, NimToolPolicy } from '../../packages/nim-core/src/index.ts';
+
+const RUNTIME_NIM_READ_TOOLS: readonly NimToolDefinition[] = [
+  {
+    name: 'directory.list',
+    description: 'List directories known to the current workspace.',
+  },
+  {
+    name: 'repository.list',
+    description: 'List repositories known to the current workspace.',
+  },
+  {
+    name: 'task.list',
+    description: 'List tasks known to the current workspace.',
+  },
+  {
+    name: 'session.list',
+    description: 'List active and historical sessions in the current workspace.',
+  },
+];
+
+const RUNTIME_NIM_READ_POLICY: NimToolPolicy = {
+  hash: 'nim-control-plane-read-v1',
+  allow: RUNTIME_NIM_READ_TOOLS.map((tool) => tool.name),
+  deny: [],
+};
+
+export interface RuntimeNimToolBridgeOptions {
+  readonly listDirectories: () => Promise<readonly unknown[]>;
+  readonly listRepositories: () => Promise<readonly unknown[]>;
+  readonly listTasks: (limit: number) => Promise<readonly unknown[]>;
+  readonly listSessions: () => Promise<readonly unknown[]>;
+  readonly taskListLimit?: number;
+}
+
+export interface RuntimeNimToolBridgeInvokeInput {
+  readonly toolName: string;
+  readonly argumentsText?: string;
+  readonly argumentsValue?: unknown;
+}
+
+export interface RuntimeNimToolRuntime {
+  registerTools(tools: readonly NimToolDefinition[]): void;
+  setToolPolicy(policy: NimToolPolicy): void;
+}
+
+export class RuntimeNimToolBridge {
+  private readonly taskListLimit: number;
+
+  constructor(private readonly options: RuntimeNimToolBridgeOptions) {
+    this.taskListLimit = Math.max(1, options.taskListLimit ?? 100);
+  }
+
+  registerWithRuntime(runtime: RuntimeNimToolRuntime): void {
+    runtime.registerTools(RUNTIME_NIM_READ_TOOLS);
+    runtime.setToolPolicy(RUNTIME_NIM_READ_POLICY);
+  }
+
+  async invoke(input: RuntimeNimToolBridgeInvokeInput): Promise<unknown> {
+    if (input.toolName === 'directory.list') {
+      const directories = await this.options.listDirectories();
+      return {
+        count: directories.length,
+        directories,
+      };
+    }
+    if (input.toolName === 'repository.list') {
+      const repositories = await this.options.listRepositories();
+      return {
+        count: repositories.length,
+        repositories,
+      };
+    }
+    if (input.toolName === 'task.list') {
+      const limitInput: {
+        readonly argumentsText: string | undefined;
+        readonly argumentsValue: unknown;
+        readonly fallback: number;
+      } = {
+        argumentsText: input.argumentsText,
+        argumentsValue: input.argumentsValue,
+        fallback: this.taskListLimit,
+      };
+      const limit = resolveTaskListLimit(limitInput);
+      const tasks = await this.options.listTasks(limit);
+      return {
+        count: tasks.length,
+        limit,
+        tasks,
+      };
+    }
+    if (input.toolName === 'session.list') {
+      const sessions = await this.options.listSessions();
+      return {
+        count: sessions.length,
+        sessions,
+      };
+    }
+    throw new Error(`unsupported nim tool: ${input.toolName}`);
+  }
+}
+
+function resolvePositiveLimit(argumentsText: string, fallback: number): number {
+  const trimmed = argumentsText.trim();
+  if (trimmed.length === 0) {
+    return fallback;
+  }
+  const parsed = Number.parseInt(trimmed, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`invalid task.list limit: ${trimmed}`);
+  }
+  return parsed;
+}
+
+function resolveTaskListLimit(input: {
+  readonly argumentsText: string | undefined;
+  readonly argumentsValue: unknown;
+  readonly fallback: number;
+}): number {
+  const value = input.argumentsValue;
+  if (typeof value === 'number') {
+    if (!Number.isInteger(value) || value <= 0) {
+      throw new Error(`invalid task.list limit: ${String(value)}`);
+    }
+    return value;
+  }
+  if (typeof value === 'object' && value !== null && 'limit' in value) {
+    const limit = (value as { readonly limit?: unknown }).limit;
+    if (typeof limit === 'number') {
+      if (!Number.isInteger(limit) || limit <= 0) {
+        throw new Error(`invalid task.list limit: ${String(limit)}`);
+      }
+      return limit;
+    }
+    if (typeof limit === 'string') {
+      return resolvePositiveLimit(limit, input.fallback);
+    }
+    throw new Error(`invalid task.list limit: ${String(limit)}`);
+  }
+  return resolvePositiveLimit(input.argumentsText ?? '', input.fallback);
+}

package/src/services/runtime-observed-event-projection-pipeline.ts

@@ -0,0 +1,45 @@
+import type { StreamObservedEvent } from '../control-plane/stream-protocol.ts';
+import {
+  applyObservedEventToHarnessSyncedStore,
+  type HarnessSyncedStore,
+  type HarnessSyncedStoreApplyResult,
+} from '../core/store/harness-synced-store.ts';
+
+export interface RuntimeObservedEventProjectionInput {
+  readonly subscriptionId: string;
+  readonly cursor: number;
+  readonly event: StreamObservedEvent;
+}
+
+export interface RuntimeObservedEventProjectionResult {
+  readonly cursorAccepted: boolean;
+  readonly previousCursor: number | null;
+}
+
+export interface RuntimeObservedEventProjectionPipelineOptions {
+  readonly syncedStore: HarnessSyncedStore;
+  readonly applyWorkspaceProjection: (reduction: HarnessSyncedStoreApplyResult) => void;
+  readonly applyTaskPlanningProjection: (reduction: HarnessSyncedStoreApplyResult) => void;
+  readonly applyDirectoryGitProjection: (event: StreamObservedEvent) => void;
+}
+
+export function applyRuntimeObservedEventProjection(
+  input: RuntimeObservedEventProjectionInput,
+  options: RuntimeObservedEventProjectionPipelineOptions,
+): RuntimeObservedEventProjectionResult {
+  const reduced = applyObservedEventToHarnessSyncedStore(options.syncedStore, input);
+  if (!reduced.cursorAccepted) {
+    return {
+      cursorAccepted: false,
+      previousCursor: reduced.previousCursor,
+    };
+  }
+  options.applyWorkspaceProjection(reduced);
+  // Directory git status updates remain an explicit non-synced projection boundary.
+  options.applyDirectoryGitProjection(input.event);
+  options.applyTaskPlanningProjection(reduced);
+  return {
+    cursorAccepted: true,
+    previousCursor: reduced.previousCursor,
+  };
+}

package/src/services/runtime-process-wiring.ts

@@ -10,7 +10,7 @@ interface RuntimeProcessTarget {
   off(event: 'unhandledRejection', listener: (reason: unknown) => void): RuntimeProcessTarget;
 }
 
-interface RuntimeProcessWiringOptions {
+export interface RuntimeProcessWiringOptions {
   readonly onInput: (chunk: Buffer) => void;
   readonly onResize: () => void;
   readonly requestStop: () => void;
@@ -18,52 +18,45 @@ interface RuntimeProcessWiringOptions {
   readonly target?: RuntimeProcessTarget;
 }
 
-export class RuntimeProcessWiring {
-  private readonly target: RuntimeProcessTarget;
-
-  constructor(private readonly options: RuntimeProcessWiringOptions) {
-    this.target = options.target ?? process;
-  }
-
-  attach(): void {
-    this.target.stdin.on('data', this.onInputSafe);
-    this.target.stdout.on('resize', this.onResizeSafe);
-    this.target.on('SIGINT', this.options.requestStop);
-    this.target.on('SIGTERM', this.options.requestStop);
-    this.target.once('uncaughtException', this.onUncaughtException);
-    this.target.once('unhandledRejection', this.onUnhandledRejection);
-  }
-
-  detach(): void {
-    this.target.stdin.off('data', this.onInputSafe);
-    this.target.stdout.off('resize', this.onResizeSafe);
-    this.target.off('SIGINT', this.options.requestStop);
-    this.target.off('SIGTERM', this.options.requestStop);
-    this.target.off('uncaughtException', this.onUncaughtException);
-    this.target.off('unhandledRejection', this.onUnhandledRejection);
-  }
-
-  private readonly onInputSafe = (chunk: Buffer): void => {
+export function attachRuntimeProcessWiring(options: RuntimeProcessWiringOptions): () => void {
+  const target = options.target ?? process;
+  const onInputSafe = (chunk: Buffer): void => {
     try {
-      this.options.onInput(chunk);
+      options.onInput(chunk);
     } catch (error: unknown) {
-      this.options.handleRuntimeFatal('stdin-data', error);
+      options.handleRuntimeFatal('stdin-data', error);
     }
   };
 
-  private readonly onResizeSafe = (): void => {
+  const onResizeSafe = (): void => {
     try {
-      this.options.onResize();
+      options.onResize();
     } catch (error: unknown) {
-      this.options.handleRuntimeFatal('stdout-resize', error);
+      options.handleRuntimeFatal('stdout-resize', error);
     }
   };
 
-  private readonly onUncaughtException = (error: Error): void => {
-    this.options.handleRuntimeFatal('uncaught-exception', error);
+  const onUncaughtException = (error: Error): void => {
+    options.handleRuntimeFatal('uncaught-exception', error);
+  };
+
+  const onUnhandledRejection = (reason: unknown): void => {
+    options.handleRuntimeFatal('unhandled-rejection', reason);
   };
 
-  private readonly onUnhandledRejection = (reason: unknown): void => {
-    this.options.handleRuntimeFatal('unhandled-rejection', reason);
+  target.stdin.on('data', onInputSafe);
+  target.stdout.on('resize', onResizeSafe);
+  target.on('SIGINT', options.requestStop);
+  target.on('SIGTERM', options.requestStop);
+  target.once('uncaughtException', onUncaughtException);
+  target.once('unhandledRejection', onUnhandledRejection);
+
+  return (): void => {
+    target.stdin.off('data', onInputSafe);
+    target.stdout.off('resize', onResizeSafe);
+    target.off('SIGINT', options.requestStop);
+    target.off('SIGTERM', options.requestStop);
+    target.off('uncaughtException', onUncaughtException);
+    target.off('unhandledRejection', onUnhandledRejection);
   };
 }

package/src/services/runtime-project-pane-github-review-cache.ts

@@ -0,0 +1,164 @@
+import type { ProjectPaneGitHubReviewSummary } from '../mux/project-pane-github-review.ts';
+
+interface QueueLatestControlPlaneOp {
+  (
+    key: string,
+    task: (options: { readonly signal: AbortSignal }) => Promise<void>,
+    label: string,
+  ): void;
+}
+
+interface RuntimeProjectPaneGitHubReviewCacheOptions {
+  readonly ttlMs: number;
+  readonly refreshIntervalMs: number;
+  readonly queueLatestControlPlaneOp: QueueLatestControlPlaneOp;
+  readonly loadReview: (
+    directoryId: string,
+    options: RuntimeProjectPaneGitHubReviewCacheRequestOptions,
+  ) => Promise<ProjectPaneGitHubReviewSummary>;
+  readonly onUpdate: (directoryId: string, review: ProjectPaneGitHubReviewSummary) => void;
+  readonly formatErrorMessage: (error: unknown) => string;
+  readonly nowMs?: () => number;
+  readonly setInterval?: (callback: () => void, ms: number) => NodeJS.Timeout;
+  readonly clearInterval?: (timer: NodeJS.Timeout) => void;
+}
+
+interface RuntimeProjectPaneGitHubReviewCacheRequestOptions {
+  readonly forceRefresh?: boolean;
+}
+
+interface CacheEntry {
+  review: ProjectPaneGitHubReviewSummary | null;
+  fetchedAtMs: number | null;
+  inFlight: boolean;
+}
+
+function loadingState(
+  previous: ProjectPaneGitHubReviewSummary | null,
+): ProjectPaneGitHubReviewSummary {
+  return {
+    status: 'loading',
+    branchName: previous?.branchName ?? null,
+    branchSource: previous?.branchSource ?? null,
+    pr: previous?.pr ?? null,
+    openThreads: previous?.openThreads ?? [],
+    resolvedThreads: previous?.resolvedThreads ?? [],
+    errorMessage: null,
+  };
+}
+
+function errorState(
+  previous: ProjectPaneGitHubReviewSummary | null,
+  message: string,
+): ProjectPaneGitHubReviewSummary {
+  return {
+    status: 'error',
+    branchName: previous?.branchName ?? null,
+    branchSource: previous?.branchSource ?? null,
+    pr: previous?.pr ?? null,
+    openThreads: previous?.openThreads ?? [],
+    resolvedThreads: previous?.resolvedThreads ?? [],
+    errorMessage: message,
+  };
+}
+
+export class RuntimeProjectPaneGitHubReviewCacheEngine {
+  private readonly entries = new Map<string, CacheEntry>();
+  private readonly nowMs: () => number;
+  private readonly setIntervalFn: (callback: () => void, ms: number) => NodeJS.Timeout;
+  private readonly clearIntervalFn: (timer: NodeJS.Timeout) => void;
+  private refreshTimer: NodeJS.Timeout | null = null;
+
+  constructor(private readonly options: RuntimeProjectPaneGitHubReviewCacheOptions) {
+    this.nowMs = options.nowMs ?? Date.now;
+    this.setIntervalFn = options.setInterval ?? setInterval;
+    this.clearIntervalFn = options.clearInterval ?? clearInterval;
+  }
+
+  request(
+    directoryId: string,
+    requestOptions: RuntimeProjectPaneGitHubReviewCacheRequestOptions = {},
+  ): void {
+    const entry = this.entries.get(directoryId) ?? {
+      review: null,
+      fetchedAtMs: null,
+      inFlight: false,
+    };
+    this.entries.set(directoryId, entry);
+    const forceRefresh = requestOptions.forceRefresh === true;
+    if (entry.inFlight) {
+      return;
+    }
+    if (!forceRefresh && this.isFresh(entry)) {
+      return;
+    }
+    const previous = entry.review;
+    entry.inFlight = true;
+    const nextLoading = loadingState(previous);
+    entry.review = nextLoading;
+    this.options.onUpdate(directoryId, nextLoading);
+
+    this.options.queueLatestControlPlaneOp(
+      `project-pane-github-review:${directoryId}`,
+      async ({ signal }) => {
+        if (signal.aborted) {
+          return;
+        }
+        try {
+          const loaded = await this.options.loadReview(directoryId, {
+            forceRefresh,
+          });
+          if (signal.aborted) {
+            return;
+          }
+          entry.review = loaded;
+          entry.fetchedAtMs = this.nowMs();
+          this.options.onUpdate(directoryId, loaded);
+        } catch (error: unknown) {
+          if (signal.aborted) {
+            return;
+          }
+          const message = this.options.formatErrorMessage(error);
+          const nextError = errorState(previous, message);
+          entry.review = nextError;
+          this.options.onUpdate(directoryId, nextError);
+        } finally {
+          entry.inFlight = false;
+        }
+      },
+      'project-pane-github-review',
+    );
+  }
+
+  startAutoRefresh(resolveDirectoryId: () => string | null): void {
+    this.stopAutoRefresh();
+    if (this.options.refreshIntervalMs <= 0) {
+      return;
+    }
+    this.refreshTimer = this.setIntervalFn(() => {
+      const directoryId = resolveDirectoryId();
+      if (directoryId === null) {
+        return;
+      }
+      this.request(directoryId);
+    }, this.options.refreshIntervalMs);
+  }
+
+  stopAutoRefresh(): void {
+    if (this.refreshTimer === null) {
+      return;
+    }
+    this.clearIntervalFn(this.refreshTimer);
+    this.refreshTimer = null;
+  }
+
+  private isFresh(entry: CacheEntry): boolean {
+    if (entry.review?.status !== 'ready') {
+      return false;
+    }
+    if (entry.fetchedAtMs === null) {
+      return false;
+    }
+    return this.nowMs() - entry.fetchedAtMs < this.options.ttlMs;
+  }
+}

package/src/services/runtime-render-flush.ts

@@ -1,10 +1,10 @@
-interface RuntimeRenderFlushResult {
+export interface RuntimeRenderFlushResult {
   readonly changedRowCount: number;
   readonly wroteOutput: boolean;
   readonly shouldShowCursor: boolean;
 }
 
-interface RuntimeRenderFlushInput<TConversation, TFrame, TSelection, TLayout> {
+export interface RuntimeRenderFlushInput<TConversation, TFrame, TSelection, TLayout> {
   readonly layout: TLayout;
   readonly projectPaneActive: boolean;
   readonly homePaneActive: boolean;
@@ -16,7 +16,7 @@ interface RuntimeRenderFlushInput<TConversation, TFrame, TSelection, TLayout> {
   readonly rightRows: readonly string[];
 }
 
-interface RuntimeRenderFlushOptions<
+export interface RuntimeRenderFlushOptions<
   TConversation,
   TFrame,
   TSelection,
@@ -66,81 +66,74 @@ interface RuntimeRenderFlushOptions<
   readonly recordRenderSample: (durationMs: number, changedRowCount: number) => void;
 }
 
-export class RuntimeRenderFlush<
+export function flushRuntimeRender<
   TConversation,
   TFrame,
   TSelection,
   TLayout,
   TModalOverlay,
   TStatusRow,
-> {
-  constructor(
-    private readonly options: RuntimeRenderFlushOptions<
-      TConversation,
-      TFrame,
-      TSelection,
-      TLayout,
-      TModalOverlay,
-      TStatusRow
-    >,
-  ) {}
-
-  flushRender(input: RuntimeRenderFlushInput<TConversation, TFrame, TSelection, TLayout>): void {
-    const renderStartedAtNs = this.options.perfNowNs();
-    const baseStatusFooter =
-      !input.projectPaneActive && !input.homePaneActive && input.activeConversation !== null
-        ? this.options.statusFooterForConversation(input.activeConversation)
-        : '';
-    const statusNotice = this.options.currentStatusNotice();
-    const statusFooter =
-      statusNotice === null || statusNotice.length === 0
-        ? baseStatusFooter
-        : `${baseStatusFooter.length > 0 ? `${baseStatusFooter}  ` : ''}${statusNotice}`;
-    const statusRow = this.options.currentStatusRow();
-    this.options.onStatusLineComposed?.({
+>(
+  options: RuntimeRenderFlushOptions<
+    TConversation,
+    TFrame,
+    TSelection,
+    TLayout,
+    TModalOverlay,
+    TStatusRow
+  >,
+  input: RuntimeRenderFlushInput<TConversation, TFrame, TSelection, TLayout>,
+): void {
+  const renderStartedAtNs = options.perfNowNs();
+  const baseStatusFooter =
+    !input.projectPaneActive && !input.homePaneActive && input.activeConversation !== null
+      ? options.statusFooterForConversation(input.activeConversation)
+      : '';
+  const statusNotice = options.currentStatusNotice();
+  const statusFooter =
+    statusNotice === null || statusNotice.length === 0
+      ? baseStatusFooter
+      : `${baseStatusFooter.length > 0 ? `${baseStatusFooter}  ` : ''}${statusNotice}`;
+  const statusRow = options.currentStatusRow();
+  options.onStatusLineComposed?.({
+    activeConversation: input.activeConversation,
+    statusFooter,
+    statusRow,
+    projectPaneActive: input.projectPaneActive,
+    homePaneActive: input.homePaneActive,
+  });
+  const rows = options.buildRenderRows(
+    input.layout,
+    input.railAnsiRows,
+    input.rightRows,
+    statusRow,
+    statusFooter,
+  );
+  const modalOverlay = options.buildModalOverlay();
+  if (modalOverlay !== null) {
+    options.applyModalOverlay(rows, modalOverlay);
+  }
+  const selectionOverlay =
+    input.rightFrame === null
+      ? ''
+      : options.renderSelectionOverlay(input.layout, input.rightFrame, input.renderSelection);
+  const flushResult = options.flush({
+    layout: input.layout,
+    rows,
+    rightFrame: input.rightFrame,
+    selectionRows: input.selectionRows,
+    selectionOverlay,
+  });
+  const changedRowCount = flushResult.changedRowCount;
+  if (flushResult.wroteOutput) {
+    options.onFlushOutput({
       activeConversation: input.activeConversation,
-      statusFooter,
-      statusRow,
-      projectPaneActive: input.projectPaneActive,
-      homePaneActive: input.homePaneActive,
-    });
-    const rows = this.options.buildRenderRows(
-      input.layout,
-      input.railAnsiRows,
-      input.rightRows,
-      statusRow,
-      statusFooter,
-    );
-    const modalOverlay = this.options.buildModalOverlay();
-    if (modalOverlay !== null) {
-      this.options.applyModalOverlay(rows, modalOverlay);
-    }
-    const selectionOverlay =
-      input.rightFrame === null
-        ? ''
-        : this.options.renderSelectionOverlay(
-            input.layout,
-            input.rightFrame,
-            input.renderSelection,
-          );
-    const flushResult = this.options.flush({
-      layout: input.layout,
-      rows,
       rightFrame: input.rightFrame,
-      selectionRows: input.selectionRows,
-      selectionOverlay,
+      rows,
+      flushResult,
+      changedRowCount,
     });
-    const changedRowCount = flushResult.changedRowCount;
-    if (flushResult.wroteOutput) {
-      this.options.onFlushOutput({
-        activeConversation: input.activeConversation,
-        rightFrame: input.rightFrame,
-        rows,
-        flushResult,
-        changedRowCount,
-      });
-    }
-    const renderDurationMs = Number(this.options.perfNowNs() - renderStartedAtNs) / 1e6;
-    this.options.recordRenderSample(renderDurationMs, changedRowCount);
   }
+  const renderDurationMs = Number(options.perfNowNs() - renderStartedAtNs) / 1e6;
+  options.recordRenderSample(renderDurationMs, changedRowCount);
 }