Add fork tags to repository UI and enhance organization cards with repository breakdown

- Add fork tags to repository table and dashboard list components
- Display 'Fork' badge for repositories where isForked is true
- Enhance organization cards to show breakdown of public, private, and fork repositories
- Update organization API to respect user configuration filters (private repos, forks)
- Add visual indicators with colored dots for each repository type
- Ensure consistent filtering between repository and organization APIs
- Fix issue where private repositories weren't showing due to configuration filtering

src/components/dashboard/RepositoryList.tsx

@@ -81,6 +81,11 @@ export function RepositoryList({ repositories }: RepositoryListProps) {
                         Private
                       </span>
                     )}
+                    {repo.isForked && (
+                      <span className="rounded-full bg-muted px-2 py-0.5 text-xs">
+                        Fork
+                      </span>
+                    )}
                   </div>
                   <div className="flex items-center gap-2 mt-1">
                     <span className="text-xs text-muted-foreground">

src/components/organizations/OrganizationsList.tsx

@@ -118,10 +118,38 @@ export function OrganizationList({
               </span>
             </div>
 
-            <p className="text-sm text-muted-foreground mb-4">
+            <div className="text-sm text-muted-foreground mb-4">
+              <div className="flex items-center justify-between">
+                <span className="font-medium">
                   {org.repositoryCount}{" "}
                   {org.repositoryCount === 1 ? "repository" : "repositories"}
-            </p>
+                </span>
+              </div>
+              {(org.publicRepositoryCount !== undefined ||
+                org.privateRepositoryCount !== undefined ||
+                org.forkRepositoryCount !== undefined) && (
+                <div className="flex gap-4 mt-2 text-xs">
+                  {org.publicRepositoryCount !== undefined && (
+                    <span className="flex items-center gap-1">
+                      <div className="h-2 w-2 rounded-full bg-green-500" />
+                      {org.publicRepositoryCount} public
+                    </span>
+                  )}
+                  {org.privateRepositoryCount !== undefined && org.privateRepositoryCount > 0 && (
+                    <span className="flex items-center gap-1">
+                      <div className="h-2 w-2 rounded-full bg-orange-500" />
+                      {org.privateRepositoryCount} private
+                    </span>
+                  )}
+                  {org.forkRepositoryCount !== undefined && org.forkRepositoryCount > 0 && (
+                    <span className="flex items-center gap-1">
+                      <div className="h-2 w-2 rounded-full bg-blue-500" />
+                      {org.forkRepositoryCount} fork{org.forkRepositoryCount !== 1 ? 's' : ''}
+                    </span>
+                  )}
+                </div>
+              )}
+            </div>
 
             <div className="flex items-center justify-between">
               <div className="flex items-center">

src/components/repositories/RepositoryTable.tsx

@@ -249,6 +249,11 @@ export default function RepositoryTable({
                       Private
                     </span>
                   )}
+                  {repo.isForked && (
+                    <span className="ml-2 rounded-full bg-muted px-2 py-0.5 text-xs">
+                      Fork
+                    </span>
+                  )}
                 </div>
 
                 {/* Owner  */}

src/lib/db/schema.ts

@@ -152,6 +152,9 @@ export const organizationSchema = z.object({
   errorMessage: z.string().optional(),
 
   repositoryCount: z.number().default(0),
+  publicRepositoryCount: z.number().optional(),
+  privateRepositoryCount: z.number().optional(),
+  forkRepositoryCount: z.number().optional(),
 
   createdAt: z.date().default(() => new Date()),
   updatedAt: z.date().default(() => new Date()),

src/pages/api/github/organizations.ts

@@ -1,7 +1,7 @@
 import type { APIRoute } from "astro";
 import { db } from "@/lib/db";
-import { organizations } from "@/lib/db";
-import { eq, sql } from "drizzle-orm";
+import { organizations, repositories, configs } from "@/lib/db";
+import { eq, sql, and, count } from "drizzle-orm";
 import {
   membershipRoleEnum,
   type OrganizationsApiResponse,
@@ -25,24 +25,114 @@ export const GET: APIRoute = async ({ request }) => {
   }
 
   try {
+    // Fetch the user's active configuration to respect filtering settings
+    const [config] = await db
+      .select()
+      .from(configs)
+      .where(and(eq(configs.userId, userId), eq(configs.isActive, true)));
+
+    if (!config) {
+      return jsonResponse({
+        data: {
+          success: false,
+          error: "No active configuration found for this user",
+        },
+        status: 404,
+      });
+    }
+
+    const githubConfig = config.githubConfig as {
+      mirrorStarred: boolean;
+      skipForks: boolean;
+      privateRepositories: boolean;
+    };
+
     const rawOrgs = await db
       .select()
       .from(organizations)
       .where(eq(organizations.userId, userId))
       .orderBy(sql`name COLLATE NOCASE`);
 
-    const orgsWithIds: Organization[] = rawOrgs.map((org) => ({
+    // Calculate repository breakdowns for each organization
+    const orgsWithBreakdown = await Promise.all(
+      rawOrgs.map(async (org) => {
+        // Build base conditions for this organization (without private/fork filters)
+        const baseConditions = [
+          eq(repositories.userId, userId),
+          eq(repositories.organization, org.name)
+        ];
+
+        if (!githubConfig.mirrorStarred) {
+          baseConditions.push(eq(repositories.isStarred, false));
+        }
+
+        // Get total count with all user config filters applied
+        const totalConditions = [...baseConditions];
+        if (githubConfig.skipForks) {
+          totalConditions.push(eq(repositories.isForked, false));
+        }
+        if (!githubConfig.privateRepositories) {
+          totalConditions.push(eq(repositories.isPrivate, false));
+        }
+
+        const [totalCount] = await db
+          .select({ count: count() })
+          .from(repositories)
+          .where(and(...totalConditions));
+
+        // Get public count
+        const publicConditions = [...baseConditions, eq(repositories.isPrivate, false)];
+        if (githubConfig.skipForks) {
+          publicConditions.push(eq(repositories.isForked, false));
+        }
+
+        const [publicCount] = await db
+          .select({ count: count() })
+          .from(repositories)
+          .where(and(...publicConditions));
+
+        // Get private count (only if private repos are enabled in config)
+        const [privateCount] = githubConfig.privateRepositories ? await db
+          .select({ count: count() })
+          .from(repositories)
+          .where(
+            and(
+              ...baseConditions,
+              eq(repositories.isPrivate, true),
+              ...(githubConfig.skipForks ? [eq(repositories.isForked, false)] : [])
+            )
+          ) : [{ count: 0 }];
+
+        // Get fork count (only if forks are enabled in config)
+        const [forkCount] = !githubConfig.skipForks ? await db
+          .select({ count: count() })
+          .from(repositories)
+          .where(
+            and(
+              ...baseConditions,
+              eq(repositories.isForked, true),
+              ...(!githubConfig.privateRepositories ? [eq(repositories.isPrivate, false)] : [])
+            )
+          ) : [{ count: 0 }];
+
+        return {
           ...org,
           status: repoStatusEnum.parse(org.status),
           membershipRole: membershipRoleEnum.parse(org.membershipRole),
           lastMirrored: org.lastMirrored ?? undefined,
           errorMessage: org.errorMessage ?? undefined,
-    }));
+          repositoryCount: totalCount.count,
+          publicRepositoryCount: publicCount.count,
+          privateRepositoryCount: privateCount.count,
+          forkRepositoryCount: forkCount.count,
+        };
+      })
+    );
 
     const resPayload: OrganizationsApiResponse = {
       success: true,
       message: "Organizations fetched successfully",
-      organizations: orgsWithIds,
+      organizations: orgsWithBreakdown,
     };
 
     return jsonResponse({ data: resPayload, status: 200 });

src/types/organizations.ts

@@ -33,6 +33,9 @@ export interface GitOrg {
   isIncluded: boolean;
   status: RepoStatus;
   repositoryCount: number;
+  publicRepositoryCount?: number;
+  privateRepositoryCount?: number;
+  forkRepositoryCount?: number;
   createdAt: Date;
   updatedAt: Date;
 }