feat(app): search GitHub repositories when adding a project

apps/mobile/src/features/projects/AddProjectScreen.logic.test.ts

@@ -2,7 +2,13 @@ import type { EnvironmentConnectionPhase } from "@t3tools/client-runtime/connect
 import { EnvironmentId } from "@t3tools/contracts";
 import { describe, expect, it } from "vite-plus/test";
 
-import { resolveAddProjectEnvironment } from "./AddProjectScreen.logic";
+import {
+  buildRepositorySearchTarget,
+  buildSearchedRepositoryDestination,
+  groupRepositorySearchResults,
+  repositorySearchEmptyState,
+  resolveAddProjectEnvironment,
+} from "./AddProjectScreen.logic";
 
 const ENVIRONMENT_A = EnvironmentId.make("environment-a");
 const ENVIRONMENT_B = EnvironmentId.make("environment-b");
@@ -39,3 +45,120 @@ describe("resolveAddProjectEnvironment", () => {
     ).toBe(ENVIRONMENT_B);
   });
 });
+
+describe("buildRepositorySearchTarget", () => {
+  const settled = {
+    environmentId: ENVIRONMENT_A,
+    provider: "github" as const,
+  };
+
+  it("fires no request below the minimum query length", () => {
+    expect(buildRepositorySearchTarget({ ...settled, query: "t", debouncedQuery: "t" })).toBeNull();
+  });
+
+  it("subscribes once the query is long enough and has settled", () => {
+    expect(
+      buildRepositorySearchTarget({ ...settled, query: " t3 ", debouncedQuery: "t3" }),
+    ).toEqual({
+      environmentId: ENVIRONMENT_A,
+      input: { provider: "github", query: "t3" },
+    });
+  });
+
+  it("blanks results while the query is still settling", () => {
+    expect(
+      buildRepositorySearchTarget({ ...settled, query: "t3co", debouncedQuery: "t3" }),
+    ).toBeNull();
+  });
+});
+
+describe("buildSearchedRepositoryDestination", () => {
+  it("navigates with the selected repository instead of looking it up again", () => {
+    expect(
+      buildSearchedRepositoryDestination({
+        environmentId: ENVIRONMENT_A,
+        source: "github",
+        result: {
+          nameWithOwner: "t3dotgg/t3code",
+          url: "https://github.com/t3dotgg/t3code",
+          sshUrl: "git@github.com:t3dotgg/t3code.git",
+          ownedByViewer: true,
+        },
+      }),
+    ).toEqual({
+      environmentId: ENVIRONMENT_A,
+      source: "github",
+      remoteUrl: "https://github.com/t3dotgg/t3code",
+      repositoryTitle: "t3dotgg/t3code",
+      repositoryName: "t3code",
+    });
+  });
+});
+
+describe("groupRepositorySearchResults", () => {
+  function result(nameWithOwner: string, ownedByViewer: boolean) {
+    return {
+      nameWithOwner,
+      url: `https://github.com/${nameWithOwner}`,
+      sshUrl: `git@github.com:${nameWithOwner}.git`,
+      ownedByViewer,
+    };
+  }
+
+  it("keeps the server ranking within a group and drops groups with no rows", () => {
+    expect(
+      groupRepositorySearchResults(
+        [result("me/one", true), result("other/two", false), result("me/three", true)],
+        "github",
+      ),
+    ).toEqual([
+      {
+        key: "owned",
+        label: "Your repositories",
+        results: [result("me/one", true), result("me/three", true)],
+      },
+      { key: "other", label: "GitHub", results: [result("other/two", false)] },
+    ]);
+    expect(groupRepositorySearchResults([result("me/one", true)], "github")).toEqual([
+      { key: "owned", label: "Your repositories", results: [result("me/one", true)] },
+    ]);
+  });
+});
+
+describe("repositorySearchEmptyState", () => {
+  const settled = { supported: true, error: null, isPending: false, canSearch: true } as const;
+
+  it("shows the ordinary empty state when a supported provider returns nothing", () => {
+    expect(repositorySearchEmptyState({ source: "github", ...settled })).toBe(
+      "No repositories match. Press Enter to look up the exact path.",
+    );
+  });
+
+  it("points at the exact-path input when the provider cannot search", () => {
+    expect(repositorySearchEmptyState({ source: "github", ...settled, supported: false })).toBe(
+      "Search is unavailable for GitHub. Enter owner/repo and press Enter.",
+    );
+  });
+
+  it("reports a failed search the same way, since the way out is the same", () => {
+    expect(repositorySearchEmptyState({ source: "github", ...settled, error: "gh exited 1" })).toBe(
+      "Search is unavailable for GitHub. Enter owner/repo and press Enter.",
+    );
+  });
+
+  it("expresses loading as a string, because the list has no spinner", () => {
+    expect(repositorySearchEmptyState({ source: "github", ...settled, isPending: true })).toBe(
+      "Searching repositories…",
+    );
+  });
+
+  it("says nothing before the query is long enough, since the placeholder already prompts", () => {
+    expect(
+      repositorySearchEmptyState({ source: "github", ...settled, canSearch: false }),
+    ).toBeNull();
+  });
+
+  it("leaves the Git URL source alone", () => {
+    expect(repositorySearchEmptyState({ source: "url", ...settled })).toBeNull();
+  });
+});

apps/mobile/src/features/projects/AddProjectScreen.logic.ts

@@ -1,6 +1,18 @@
-import { canCreateProjectInEnvironment } from "@t3tools/client-runtime/operations/projects";
+import {
+  addProjectRemoteSourceLabel,
+  addProjectRemoteSourcePathHint,
+  canCreateProjectInEnvironment,
+  getCloneDirectoryName,
+  getDefaultCloneUrl,
+  type AddProjectRemoteProviderKind,
+  type AddProjectRemoteSource,
+} from "@t3tools/client-runtime/operations/projects";
 import type { EnvironmentConnectionPhase } from "@t3tools/client-runtime/connection";
-import type { EnvironmentId } from "@t3tools/contracts";
+import type {
+  EnvironmentId,
+  SourceControlRepositorySearchInput,
+  SourceControlRepositorySearchResult,
+} from "@t3tools/contracts";
 
 export function resolveAddProjectEnvironment<
   T extends {
@@ -24,3 +36,104 @@ export function resolveAddProjectEnvironment<
     ) ?? null
   );
 }
+
+export const REPOSITORY_SEARCH_DEBOUNCE_MS = 200;
+export const REPOSITORY_SEARCH_MIN_QUERY_LENGTH = 2;
+
+/**
+ * Target for the repository search query, or null to leave it unsubscribed. Null below the minimum
+ * length keeps short prefixes off the wire, and null while the typed query still differs from the
+ * debounced one blanks the list rather than leaving a previous owner prefix's matches on screen.
+ */
+export function buildRepositorySearchTarget(input: {
+  readonly environmentId: EnvironmentId | null;
+  readonly provider: AddProjectRemoteProviderKind | null;
+  readonly query: string;
+  readonly debouncedQuery: string;
+}): {
+  readonly environmentId: EnvironmentId;
+  readonly input: SourceControlRepositorySearchInput;
+} | null {
+  const query = input.query.trim();
+  if (input.environmentId === null || input.provider === null) return null;
+  if (query.length < REPOSITORY_SEARCH_MIN_QUERY_LENGTH) return null;
+  if (query !== input.debouncedQuery.trim()) return null;
+  return {
+    environmentId: input.environmentId,
+    input: { provider: input.provider, query },
+  };
+}
+
+/** A searched row already carries both clone URLs, so selecting one skips the lookup round trip. */
+export function buildSearchedRepositoryDestination(input: {
+  readonly environmentId: EnvironmentId;
+  readonly source: AddProjectRemoteProviderKind;
+  readonly result: SourceControlRepositorySearchResult;
+}): {
+  readonly environmentId: EnvironmentId;
+  readonly source: AddProjectRemoteProviderKind;
+  readonly remoteUrl: string;
+  readonly repositoryTitle: string;
+  readonly repositoryName: string;
+} {
+  return {
+    environmentId: input.environmentId,
+    source: input.source,
+    remoteUrl: getDefaultCloneUrl({
+      provider: input.source,
+      url: input.result.url,
+      sshUrl: input.result.sshUrl,
+    }),
+    repositoryTitle: input.result.nameWithOwner,
+    repositoryName: getCloneDirectoryName(input.result.nameWithOwner),
+  };
+}
+
+export interface RepositorySearchGroup {
+  readonly key: string;
+  readonly label: string;
+  readonly results: ReadonlyArray<SourceControlRepositorySearchResult>;
+}
+
+/**
+ * Splits results into the two rendered groups. Ranking, the 20-result cap, and description
+ * truncation all happen server-side, so group membership is the only client decision left.
+ */
+export function groupRepositorySearchResults(
+  results: ReadonlyArray<SourceControlRepositorySearchResult>,
+  source: AddProjectRemoteProviderKind,
+): ReadonlyArray<RepositorySearchGroup> {
+  const owned = results.filter((result) => result.ownedByViewer);
+  const others = results.filter((result) => !result.ownedByViewer);
+  const groups: RepositorySearchGroup[] = [];
+  if (owned.length > 0) {
+    groups.push({ key: "owned", label: "Your repositories", results: owned });
+  }
+  if (others.length > 0) {
+    groups.push({ key: "other", label: addProjectRemoteSourceLabel(source), results: others });
+  }
+  return groups;
+}
+
+/**
+ * The one line rendered under the input when the search has no rows to show. Both empty successes
+ * stay here rather than becoming errors: a paused rate-limit circuit answers `supported: true` with
+ * no results and gets the ordinary empty state, while a provider that cannot search answers
+ * `supported: false` and gets the affordance pointing back at the exact-path input. Loading is a
+ * string because this screen has no spinner for the list.
+ */
+export function repositorySearchEmptyState(input: {
+  readonly source: AddProjectRemoteSource;
+  readonly supported: boolean;
+  readonly error: string | null;
+  readonly isPending: boolean;
+  readonly canSearch: boolean;
+}): string | null {
+  if (input.source === "url") return null;
+  if (!input.canSearch) return null;
+  if (!input.supported || input.error !== null) {
+    return `Search is unavailable for ${addProjectRemoteSourceLabel(input.source)}. Enter ${addProjectRemoteSourcePathHint(input.source)} and press Enter.`;
+  }
+  if (input.isPending) return "Searching repositories…";
+  return "No repositories match. Press Enter to look up the exact path.";
+}