git

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93// Own one repository status reader and one panel state in the plugin scope.
// Changes during a read coalesce into one follow-up read, just as before conversion.
import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Stream from "effect/Stream";
import { Host, Plugin, Services } from "convergence/effect";
import type { ViewHandle } from "convergence";
import type { Tabs } from "../tabs/contract.ts";
import { makeActions } from "./actions.ts";
import { initialState } from "./status.ts";

const makeGit = Effect.fn("Git.make")(function* () {
  const host = yield* Host;
  const plugin = yield* Plugin;
  const services = yield* Services;
  const scope = yield* Effect.scope;
  const state = initialState();
  const views: ViewHandle[] = [];
  const redraw = () => {
    for (const view of views) view.update();
  };
  let loading = false;
  let again = false;
  const refresh = Effect.fn("Git.refresh")(function* () {
    if (!state.workspaceId) return;
    if (loading) {
      again = true;
      return;
    }
    do {
      const workspaceId = state.workspaceId;
      if (!workspaceId) return;
      loading = true;
      yield* host.call("host/git.status", { workspaceId }).pipe(
        Effect.tap((status) =>
          Effect.sync(() => {
            if (workspaceId === state.workspaceId) Object.assign(state, { status, error: null });
          }),
        ),
        Effect.catchTag(["HostCallFailed", "NeedsReview", "PermissionNotGranted"], (error) =>
          Effect.sync(() => {
            if (workspaceId === state.workspaceId) state.error = error.message;
          }),
        ),
        Effect.ensuring(
          Effect.sync(() => {
            loading = false;
          }),
        ),
      );
      redraw();
      if (!again) return;
      again = false;
    } while (true);
  });
  const show = Effect.fn("Git.show")(function* (workspaceId: string | undefined) {
    if (!workspaceId || workspaceId === state.workspaceId) return;
    Object.assign(state, { workspaceId, status: null, error: null, confirm: null, menuOpen: false, branchOpen: false });
    redraw();
    // Older hosts lack watch; preserve their turn-finished/manual-refresh fallback.
    const watch: unknown = plugin.api.host.git.watch;
    if (typeof watch === "function")
      yield* Effect.forkIn(
        host
          .call("host/git.watch", { workspaceId })
          .pipe(
            Effect.catchTag(["HostCallFailed", "NeedsReview", "PermissionNotGranted"], (error) =>
              Effect.sync(() => console.warn(`git watch failed: ${error.message}`)),
            ),
          ),
        scope,
        { startImmediately: true },
      );
    yield* refresh();
  });
  const actions = yield* makeActions(state, refresh, redraw);
  // Diffs and files need the tabs plugin; without it they stay closed, as
  // the shared request they replaced would have had no reader.
  yield* services.when<typeof Tabs>("convergence/tabs").pipe(
    Stream.runForEach((option) =>
      Effect.sync(() => {
        state.tabs = option._tag === "Some" ? option.value : undefined;
      }),
    ),
    Effect.forkIn(scope, { startImmediately: true }),
  );
  return { state, views, refresh, show, ...actions };
});

export class Git extends Context.Service<Git, Effect.Success<ReturnType<typeof makeGit>>>()("git/Git") {
  static readonly layer = Layer.effect(Git, makeGit());
}