Merge pull request pingdotgg#2 from ntheile/header-tabs

Add thread header tabs and persistent thread notes

Author: ntheile

AGENTS.md

@@ -39,13 +39,18 @@ Long term maintainability is a core priority. If you add new functionality, firs
 ### Live Web Deploy Flow
 
 - When the user asks to make a web change live, rebuild `apps/web` first, then rebuild `apps/server`, then restart `t3code-web.service`.
+- Do not build `apps/web` and `apps/server` in parallel for a deploy. The server build copies the current web build into `apps/server/dist/client`, so parallel builds can deploy stale frontend assets even when both builds succeed.
 - Use this exact order:
   1. `cd apps/web && bun run build`
   2. `cd apps/server && bun run build`
   3. `systemctl --user restart t3code-web.service`
+- In this environment, `bun` may not be on `PATH` inside tool-run shells. If `bun: command not found` appears, prefix commands with `export PATH="$HOME/.bun/bin:$PATH" && ...`.
 - After restarting, verify the deploy instead of assuming it worked. Check both:
   - service state via `systemctl --user show t3code-web.service -p MainPID -p ExecMainStartTimestamp -p ActiveState -p SubState`
   - rebuilt artifact timestamps for `apps/web/dist/index.html`, `apps/server/dist/index.mjs`, and `apps/server/dist/client/index.html`
+- The tool wrapper may report `systemctl --user restart t3code-web.service` as `aborted` even when the restart actually succeeded. Treat `systemctl --user show ...`, artifact timestamps, and the live served asset hash as the source of truth.
+- When verifying the live frontend, also check the served asset hash directly, for example:
+  - `curl -s "$APP_URL" | rg -o '/assets/index-[^" ]+\\.(js|css)'`
 
 ## Package Roles
 

apps/server/src/git/Layers/GitCore.test.ts

@@ -262,6 +262,7 @@ it.layer(TestLayer)("git integration", (it) => {
         const result = yield* listGitBranches({ cwd: tmp });
         expect(result.isRepo).toBe(true);
         expect(result.hasOriginRemote).toBe(false);
+        expect(result.originWebUrl).toBeNull();
         expect(result.branches.length).toBeGreaterThanOrEqual(1);
       }),
     );
@@ -276,6 +277,7 @@ it.layer(TestLayer)("git integration", (it) => {
         const result = yield* listGitBranches({ cwd: tmp });
         expect(result.isRepo).toBe(false);
         expect(result.hasOriginRemote).toBe(false);
+        expect(result.originWebUrl).toBeNull();
         expect(result.branches).toEqual([]);
       }),
     );
@@ -435,6 +437,7 @@ it.layer(TestLayer)("git integration", (it) => {
         const firstRemoteIndex = result.branches.findIndex((branch) => branch.isRemote);
 
         expect(result.hasOriginRemote).toBe(true);
+        expect(result.originWebUrl).toBeNull();
         expect(firstRemoteIndex).toBeGreaterThan(0);
         expect(result.branches.slice(0, firstRemoteIndex).every((branch) => !branch.isRemote)).toBe(
           true,

apps/server/src/git/Layers/GitCore.ts

@@ -1,6 +1,7 @@
 import { Cache, Data, Duration, Effect, Exit, FileSystem, Layer, Path } from "effect";
 
 import { GitCommandError } from "../Errors.ts";
+import { parseGitHubWebUrlFromRemoteUrl } from "../githubRemote.ts";
 import { GitService } from "../Services/GitService.ts";
 import { GitCore, type GitCoreShape } from "../Services/GitCore.ts";
 
@@ -1071,7 +1072,7 @@ export const makeGitCore = Effect.gen(function* () {
       if (localBranchResult.code !== 0) {
         const stderr = localBranchResult.stderr.trim();
         if (stderr.toLowerCase().includes("not a git repository")) {
-          return { branches: [], isRepo: false, hasOriginRemote: false };
+          return { branches: [], isRepo: false, hasOriginRemote: false, originWebUrl: null };
         }
         return yield* createGitCommandError(
           "GitCore.listBranches",
@@ -1113,33 +1114,42 @@ export const makeGitCore = Effect.gen(function* () {
         ),
       );
 
-      const [defaultRef, worktreeList, remoteBranchResult, remoteNamesResult, branchLastCommit] =
-        yield* Effect.all(
-          [
-            executeGit(
-              "GitCore.listBranches.defaultRef",
-              input.cwd,
-              ["symbolic-ref", "refs/remotes/origin/HEAD"],
-              {
-                timeoutMs: 5_000,
-                allowNonZeroExit: true,
-              },
-            ),
-            executeGit(
-              "GitCore.listBranches.worktreeList",
-              input.cwd,
-              ["worktree", "list", "--porcelain"],
-              {
-                timeoutMs: 5_000,
-                allowNonZeroExit: true,
-              },
-            ),
-            remoteBranchResultEffect,
-            remoteNamesResultEffect,
-            branchRecencyPromise,
-          ],
-          { concurrency: "unbounded" },
-        );
+      const [
+        defaultRef,
+        worktreeList,
+        remoteBranchResult,
+        remoteNamesResult,
+        originRemoteUrl,
+        branchLastCommit,
+      ] = yield* Effect.all(
+        [
+          executeGit(
+            "GitCore.listBranches.defaultRef",
+            input.cwd,
+            ["symbolic-ref", "refs/remotes/origin/HEAD"],
+            {
+              timeoutMs: 5_000,
+              allowNonZeroExit: true,
+            },
+          ),
+          executeGit(
+            "GitCore.listBranches.worktreeList",
+            input.cwd,
+            ["worktree", "list", "--porcelain"],
+            {
+              timeoutMs: 5_000,
+              allowNonZeroExit: true,
+            },
+          ),
+          remoteBranchResultEffect,
+          remoteNamesResultEffect,
+          readConfigValue(input.cwd, "remote.origin.url").pipe(
+            Effect.catch(() => Effect.succeed(null)),
+          ),
+          branchRecencyPromise,
+        ],
+        { concurrency: "unbounded" },
+      );
 
       const remoteNames =
         remoteNamesResult.code === 0 ? parseRemoteNames(remoteNamesResult.stdout) : [];
@@ -1237,7 +1247,12 @@ export const makeGitCore = Effect.gen(function* () {
 
       const branches = [...localBranches, ...remoteBranches];
 
-      return { branches, isRepo: true, hasOriginRemote: remoteNames.includes("origin") };
+      return {
+        branches,
+        isRepo: true,
+        hasOriginRemote: remoteNames.includes("origin"),
+        originWebUrl: parseGitHubWebUrlFromRemoteUrl(originRemoteUrl),
+      };
     });
 
   const createWorktree: GitCoreShape["createWorktree"] = (input) =>

apps/server/src/git/githubRemote.ts

@@ -0,0 +1,15 @@
+export function parseGitHubWebUrlFromRemoteUrl(url: string | null): string | null {
+  const trimmed = url?.trim() ?? "";
+  if (trimmed.length === 0) {
+    return null;
+  }
+
+  const match =
+    /^(?:git@github\.com:|ssh:\/\/git@github\.com\/|https:\/\/github\.com\/|git:\/\/github\.com\/)([^/\s]+\/[^/\s]+?)(?:\.git)?\/?$/i.exec(
+      trimmed,
+    );
+  const repositoryNameWithOwner = match?.[1]?.trim() ?? "";
+  return repositoryNameWithOwner.length > 0
+    ? `https://github.com/${repositoryNameWithOwner}`
+    : null;
+}

apps/server/src/persistence/Layers/ThreadNotes.ts

@@ -0,0 +1,88 @@
+import {
+  type ThreadNotesDocument as ThreadNotesDocumentRecord,
+  ThreadNotesDocument,
+  ThreadNotesGetInput,
+} from "@t3tools/contracts";
+import { Effect, Layer, Option } from "effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import * as SqlSchema from "effect/unstable/sql/SqlSchema";
+
+import { toPersistenceSqlError } from "../Errors.ts";
+import { ThreadNotesRepository, type ThreadNotesRepositoryShape } from "../Services/ThreadNotes.ts";
+
+const makeThreadNotesRepository = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+
+  const upsertThreadNotesRow = SqlSchema.void({
+    Request: ThreadNotesDocument,
+    execute: (row) =>
+      sql`
+        INSERT INTO thread_notes (
+          thread_id,
+          notes,
+          created_at,
+          updated_at
+        )
+        VALUES (
+          ${row.threadId},
+          ${row.notes},
+          ${row.createdAt},
+          ${row.updatedAt}
+        )
+        ON CONFLICT (thread_id)
+        DO UPDATE SET
+          notes = excluded.notes,
+          created_at = excluded.created_at,
+          updated_at = excluded.updated_at
+      `,
+  });
+
+  const getThreadNotesRow = SqlSchema.findOneOption({
+    Request: ThreadNotesGetInput,
+    Result: ThreadNotesDocument,
+    execute: ({ threadId }) =>
+      sql`
+        SELECT
+          thread_id AS "threadId",
+          notes,
+          created_at AS "createdAt",
+          updated_at AS "updatedAt"
+        FROM thread_notes
+        WHERE thread_id = ${threadId}
+      `,
+  });
+
+  const getByThreadId: ThreadNotesRepositoryShape["getByThreadId"] = (input) =>
+    getThreadNotesRow(input).pipe(
+      Effect.mapError(toPersistenceSqlError("ThreadNotesRepository.getByThreadId:query")),
+    );
+
+  const upsert: ThreadNotesRepositoryShape["upsert"] = (input) =>
+    Effect.gen(function* () {
+      const existing = yield* getByThreadId({ threadId: input.threadId });
+      const timestamp = new Date().toISOString();
+      const row: ThreadNotesDocumentRecord = {
+        threadId: input.threadId,
+        notes: input.notes,
+        createdAt: Option.match(existing, {
+          onNone: () => timestamp,
+          onSome: (document) => document.createdAt,
+        }),
+        updatedAt: timestamp,
+      };
+      yield* upsertThreadNotesRow(row).pipe(
+        Effect.mapError(toPersistenceSqlError("ThreadNotesRepository.upsert:query")),
+      );
+      return row;
+    });
+
+  return {
+    getByThreadId,
+    upsert,
+  } satisfies ThreadNotesRepositoryShape;
+});
+
+export const ThreadNotesRepositoryLive = Layer.effect(
+  ThreadNotesRepository,
+  makeThreadNotesRepository,
+);

apps/server/src/persistence/Migrations.ts

@@ -28,6 +28,7 @@ import Migration0013 from "./Migrations/013_ProjectionThreadProposedPlans.ts";
 import Migration0014 from "./Migrations/014_RemoteTargetColumns.ts";
 import Migration0015 from "./Migrations/015_ExecutionTargets.ts";
 import Migration0016 from "./Migrations/016_ProjectTargetColumns.ts";
+import Migration0017 from "./Migrations/017_ThreadNotes.ts";
 import { Effect } from "effect";
 
 /**
@@ -57,6 +58,7 @@ const loader = Migrator.fromRecord({
   "14_RemoteTargetColumns": Migration0014,
   "15_ExecutionTargets": Migration0015,
   "16_ProjectTargetColumns": Migration0016,
+  "17_ThreadNotes": Migration0017,
 });
 
 /**

apps/server/src/persistence/Migrations/017_ThreadNotes.ts

@@ -0,0 +1,20 @@
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+export default Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+
+  yield* sql`
+    CREATE TABLE IF NOT EXISTS thread_notes (
+      thread_id TEXT PRIMARY KEY,
+      notes TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `;
+
+  yield* sql`
+    CREATE INDEX IF NOT EXISTS idx_thread_notes_updated_at
+    ON thread_notes(updated_at)
+  `;
+});

apps/server/src/persistence/Services/ThreadNotes.ts

@@ -0,0 +1,23 @@
+import {
+  type ThreadNotesDocument,
+  ThreadNotesGetInput,
+  ThreadNotesUpsertInput,
+} from "@t3tools/contracts";
+import { Option, ServiceMap } from "effect";
+import type { Effect } from "effect";
+
+import type { ProjectionRepositoryError } from "../Errors.ts";
+
+export interface ThreadNotesRepositoryShape {
+  readonly getByThreadId: (
+    input: typeof ThreadNotesGetInput.Type,
+  ) => Effect.Effect<Option.Option<ThreadNotesDocument>, ProjectionRepositoryError>;
+  readonly upsert: (
+    input: typeof ThreadNotesUpsertInput.Type,
+  ) => Effect.Effect<ThreadNotesDocument, ProjectionRepositoryError>;
+}
+
+export class ThreadNotesRepository extends ServiceMap.Service<
+  ThreadNotesRepository,
+  ThreadNotesRepositoryShape
+>()("t3/persistence/Services/ThreadNotes/ThreadNotesRepository") {}

apps/server/src/serverLayers.ts

@@ -11,6 +11,7 @@ import { OrchestrationCommandReceiptRepositoryLive } from "./persistence/Layers/
 import { OrchestrationEventStoreLive } from "./persistence/Layers/OrchestrationEventStore";
 import { ProviderSessionRuntimeRepositoryLive } from "./persistence/Layers/ProviderSessionRuntime";
 import { ExecutionTargetRepositoryLive } from "./persistence/Layers/ExecutionTargets";
+import { ThreadNotesRepositoryLive } from "./persistence/Layers/ThreadNotes";
 import { OrchestrationEngineLive } from "./orchestration/Layers/OrchestrationEngine";
 import { CheckpointReactorLive } from "./orchestration/Layers/CheckpointReactor";
 import { OrchestrationReactorLive } from "./orchestration/Layers/OrchestrationReactor";
@@ -151,5 +152,6 @@ export function makeServerRuntimeServicesLayer() {
     KeybindingsLive,
     executionTargetServiceLayer,
     executionTargetRuntimeLayer,
+    ThreadNotesRepositoryLive,
   ).pipe(Layer.provideMerge(NodeServices.layer));
 }

apps/server/src/wsServer.test.ts

@@ -1715,6 +1715,7 @@ describe("WebSocket Server", () => {
         branches: [],
         isRepo: false,
         hasOriginRemote: false,
+        originWebUrl: null,
       }),
     );
     const initRepo = vi.fn(() => Effect.void);
@@ -1745,7 +1746,12 @@ describe("WebSocket Server", () => {
 
     const listResponse = await sendRequest(ws, WS_METHODS.gitListBranches, { cwd: "/repo/path" });
     expect(listResponse.error).toBeUndefined();
-    expect(listResponse.result).toEqual({ branches: [], isRepo: false, hasOriginRemote: false });
+    expect(listResponse.result).toEqual({
+      branches: [],
+      isRepo: false,
+      hasOriginRemote: false,
+      originWebUrl: null,
+    });
     expect(listBranches).toHaveBeenCalledWith({ cwd: "/repo/path" });
 
     const initResponse = await sendRequest(ws, WS_METHODS.gitInit, { cwd: "/repo/path" });