Refactor: Move account age checks to rules folder

This commit moves the account age related checks into the
`rules/account` folder, organizing the project structure.

feat: Add Prettier config and plugins

feat: Add ESLint config and plugins

fix: Fix missing import for Agent

feat: Implement metrics endpoint

refactor: Improve test organization

fix: Mock fetch in age.test.ts

fix: Add tests for countStarterPacks

refactor: Move account age checks to rules folder

feat: Add tests for facet spam detection

.github/workflows/ci.yml

···
       - name: Install dependencies
         run: bun install
 
-#      - name: Run linter
-#        run: npm run lint
+      #      - name: Run linter
+      #        run: npm run lint
 
       - name: Type check
         run: npx tsc --noEmit

.prettierrc.json

···
+{
+  "plugins": ["@trivago/prettier-plugin-sort-imports"],
+  "importOrder": [
+    "^node:",
+    "<THIRD_PARTY_MODULES>",
+    "^@atproto/(.*)$",
+    "^@skyware/(.*)$",
+    "^@clavata/(.*)$",
+    "^[./]"
+  ],
+  "importOrderSeparation": false,
+  "importOrderSortSpecifiers": true
+}

eslint.config.mjs

···
 import eslint from "@eslint/js";
-import tseslint from "typescript-eslint";
 import stylistic from "@stylistic/eslint-plugin";
 import prettier from "eslint-config-prettier";
 import importPlugin from "eslint-plugin-import";
+import tseslint from "typescript-eslint";
 
 export default tseslint.config(
   eslint.configs.recommended,

src/agent.ts

···
-import { setGlobalDispatcher, Agent as Agent } from "undici";
+import { Agent, setGlobalDispatcher } from "undici";
+import { AtpAgent } from "@atproto/api";
+import { BSKY_HANDLE, BSKY_PASSWORD, OZONE_PDS } from "./config.js";
+
 setGlobalDispatcher(new Agent({ connect: { timeout: 20_000 } }));
-import { BSKY_HANDLE, BSKY_PASSWORD, OZONE_PDS } from "./config.js";
-import { AtpAgent } from "@atproto/api";
 
 export const agent = new AtpAgent({
   service: `https://${OZONE_PDS}`,

src/limits.ts

···
-import { pRateLimit } from "p-ratelimit"; // TypeScript
+import { pRateLimit } from "p-ratelimit";
+
+// TypeScript
 
 // create a rate limiter that allows up to 30 API calls per second,
 // with max concurrency of 10

src/main.ts

···
+import fs from "node:fs";
 import {
   CommitCreateEvent,
   CommitUpdateEvent,
   IdentityEvent,
   Jetstream,
 } from "@skyware/jetstream";
-import fs from "node:fs";
-
 import {
   CURSOR_UPDATE_INTERVAL,
   FIREHOSE_URL,
···
 } from "./config.js";
 import { logger } from "./logger.js";
 import { startMetricsServer } from "./metrics.js";
-import { Post, LinkFeature, Handle } from "./types.js";
+import { checkAccountAge } from "./rules/account/age.js";
+import { checkFacetSpam } from "./rules/facets/facets.js";
+import { checkHandle } from "./rules/handles/checkHandles.js";
 import { checkPosts } from "./rules/posts/checkPosts.js";
-import { checkHandle } from "./rules/handles/checkHandles.js";
 import {
   checkDescription,
   checkDisplayName,
 } from "./rules/profiles/checkProfiles.js";
-import { checkFacetSpam } from "./rules/facets/facets.js";
-import { checkAccountAge } from "./rules/account/age.js";
+import { Handle, LinkFeature, Post } from "./types.js";
 
 let cursor = 0;
 let cursorUpdateInterval: NodeJS.Timeout;

src/metrics.ts

···
 import express from "express";
 import { Registry, collectDefaultMetrics } from "prom-client";
-
 import { logger } from "./logger.js";
 
 const register = new Registry();

src/rules/account/age.ts

···
 import { agent, isLoggedIn } from "../../agent.js";
-import { logger } from "../../logger.js";
-import { createAccountLabel, checkAccountLabels } from "../../moderation.js";
-import { ACCOUNT_AGE_CHECKS } from "./ageConstants.js";
 import { PLC_URL } from "../../config.js";
 import { GLOBAL_ALLOW } from "../../constants.js";
+import { logger } from "../../logger.js";
+import { checkAccountLabels, createAccountLabel } from "../../moderation.js";
+import { ACCOUNT_AGE_CHECKS } from "./ageConstants.js";
 
 interface InteractionContext {
   // For replies

src/rules/account/countStarterPacks.ts

···
-import { isLoggedIn, agent } from "../../agent.js";
-import { logger } from "../../logger.js";
+import { agent, isLoggedIn } from "../../agent.js";
 import { limit } from "../../limits.js";
+import { logger } from "../../logger.js";
 import { createAccountLabel } from "../../moderation.js";
 
 const ALLOWED_DIDS = ["did:plc:gpunjjgvlyb4racypz3yfiq4"];

src/rules/account/tests/age.test.ts

···
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { agent } from "../../../agent.js";
+import { GLOBAL_ALLOW } from "../../../constants.js";
+import { logger } from "../../../logger.js";
+import { checkAccountLabels, createAccountLabel } from "../../../moderation.js";
 import {
   calculateAccountAge,
   checkAccountAge,
···
 
 // Mock fetch for DID document lookups
 global.fetch = vi.fn();
-
-import { agent } from "../../../agent.js";
-import { logger } from "../../../logger.js";
-import { createAccountLabel, checkAccountLabels } from "../../../moderation.js";
-import { GLOBAL_ALLOW } from "../../../constants.js";
 
 describe("Account Age Module", () => {
   beforeEach(() => {

src/rules/account/tests/countStarterPacks.test.ts

···
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { agent } from "../../../agent.js";
+import { limit } from "../../../limits.js";
+import { logger } from "../../../logger.js";
+import { createAccountLabel } from "../../../moderation.js";
 import { countStarterPacks } from "../countStarterPacks.js";
 
 // Mock dependencies
···
 vi.mock("../../../limits.js", () => ({
   limit: vi.fn((fn) => fn()),
 }));
-
-import { agent } from "../../../agent.js";
-import { logger } from "../../../logger.js";
-import { createAccountLabel } from "../../../moderation.js";
-import { limit } from "../../../limits.js";
 
 describe("countStarterPacks", () => {
   beforeEach(() => {

src/rules/facets/facets.ts

···
-import { createAccountLabel } from "../../moderation.js";
 import { logger } from "../../logger.js";
+import { createAccountLabel } from "../../moderation.js";
 import { Facet } from "../../types.js";
 
 // Threshold for duplicate facet positions before flagging as spam

src/rules/facets/tests/facets.test.ts

···
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { logger } from "../../../logger.js";
+import { createAccountLabel } from "../../../moderation.js";
+import { Facet } from "../../../types.js";
 import {
-  checkFacetSpam,
-  FACET_SPAM_THRESHOLD,
+  FACET_SPAM_ALLOWLIST,
+  FACET_SPAM_COMMENT,
   FACET_SPAM_LABEL,
-  FACET_SPAM_COMMENT,
-  FACET_SPAM_ALLOWLIST,
+  FACET_SPAM_THRESHOLD,
+  checkFacetSpam,
 } from "../facets.js";
-import { Facet } from "../../../types.js";
 
 // Mock dependencies
 vi.mock("../../../moderation.js", () => ({
···
     error: vi.fn(),
   },
 }));
-
-import { createAccountLabel } from "../../../moderation.js";
-import { logger } from "../../../logger.js";
 
 describe("checkFacetSpam", () => {
   const TEST_DID = "did:plc:test123";

src/rules/handles/checkHandles.test.ts

···
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { checkHandle } from "./checkHandles.js";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import {
-  createAccountReport,
   createAccountComment,
   createAccountLabel,
+  createAccountReport,
 } from "../../moderation.js";
+import { checkHandle } from "./checkHandles.js";
 
 // Mock dependencies
 vi.mock("../../moderation.js", () => ({

src/rules/handles/checkHandles.ts

···
-import { HANDLE_CHECKS } from "./constants.js";
+import { GLOBAL_ALLOW } from "../../constants.js";
 import { logger } from "../../logger.js";
 import {
-  createAccountReport,
   createAccountComment,
   createAccountLabel,
+  createAccountReport,
 } from "../../moderation.js";
-import { GLOBAL_ALLOW } from "../../constants.js";
+import { HANDLE_CHECKS } from "./constants.js";
 
 export const checkHandle = async (
   did: string,

src/rules/posts/checkPosts.ts

···
-import { LINK_SHORTENER, POST_CHECKS } from "./constants.js";
-import { Post } from "../../types.js";
+import { GLOBAL_ALLOW } from "../../constants.js";
 import { logger } from "../../logger.js";
-import { countStarterPacks } from "../account/countStarterPacks.js";
 import {
-  createPostLabel,
+  createAccountComment,
   createAccountReport,
-  createAccountComment,
+  createPostLabel,
   createPostReport,
 } from "../../moderation.js";
+import { Post } from "../../types.js";
+import { getFinalUrl } from "../../utils/getFinalUrl.js";
 import { getLanguage } from "../../utils/getLanguage.js";
-import { getFinalUrl } from "../../utils/getFinalUrl.js";
-import { GLOBAL_ALLOW } from "../../constants.js";
+import { countStarterPacks } from "../account/countStarterPacks.js";
+import { LINK_SHORTENER, POST_CHECKS } from "./constants.js";
 
 export const checkPosts = async (post: Post[]) => {
   if (GLOBAL_ALLOW.includes(post[0].did)) {

src/rules/posts/tests/checkPosts.test.ts

···
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { checkPosts } from "../checkPosts.js";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { logger } from "../../../logger.js";
+import {
+  createAccountComment,
+  createAccountReport,
+  createPostLabel,
+  createPostReport,
+} from "../../../moderation.js";
 import { Post } from "../../../types.js";
+import { getFinalUrl } from "../../../utils/getFinalUrl.js";
+import { getLanguage } from "../../../utils/getLanguage.js";
+import { countStarterPacks } from "../../account/countStarterPacks.js";
+import { checkPosts } from "../checkPosts.js";
 
 // Mock dependencies
 vi.mock("../constants.js", () => ({
···
 vi.mock("../../../constants.js", () => ({
   GLOBAL_ALLOW: ["did:plc:globalallow"],
 }));
-
-import { logger } from "../../../logger.js";
-import { countStarterPacks } from "../../account/countStarterPacks.js";
-import {
-  createPostLabel,
-  createAccountReport,
-  createAccountComment,
-  createPostReport,
-} from "../../../moderation.js";
-import { getLanguage } from "../../../utils/getLanguage.js";
-import { getFinalUrl } from "../../../utils/getFinalUrl.js";
 
 describe("checkPosts", () => {
   beforeEach(() => {

src/rules/profiles/checkProfiles.ts

···
-import { PROFILE_CHECKS } from "../../rules/profiles/constants.js";
+import { GLOBAL_ALLOW } from "../../constants.js";
 import { logger } from "../../logger.js";
 import {
-  createAccountReport,
-  createAccountLabel,
   createAccountComment,
+  createAccountLabel,
+  createAccountReport,
 } from "../../moderation.js";
+import { PROFILE_CHECKS } from "../../rules/profiles/constants.js";
 import { getLanguage } from "../../utils/getLanguage.js";
-import { GLOBAL_ALLOW } from "../../constants.js";
 
 export const checkDescription = async (
   did: string,

src/rules/profiles/tests/checkProfiles.test.ts

···
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { logger } from "../../../logger.js";
+import {
+  createAccountComment,
+  createAccountLabel,
+  createAccountReport,
+} from "../../../moderation.js";
+import { getLanguage } from "../../../utils/getLanguage.js";
 import { checkDescription, checkDisplayName } from "../checkProfiles.js";
 
 // Mock dependencies
···
 vi.mock("../../../constants.js", () => ({
   GLOBAL_ALLOW: ["did:plc:globalallow"],
 }));
-
-import { logger } from "../../../logger.js";
-import {
-  createAccountLabel,
-  createAccountReport,
-  createAccountComment,
-} from "../../../moderation.js";
-import { getLanguage } from "../../../utils/getLanguage.js";
 
 describe("checkProfiles", () => {
   beforeEach(() => {

src/tests/agent.test.ts

···
-import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from "vitest";
 
-describe('Agent', () => {
+describe("Agent", () => {
   beforeEach(() => {
-    vi.resetModules()
-  })
+    vi.resetModules();
+  });
 
-  it('should create an agent and login', async () => {
+  it("should create an agent and login", async () => {
     // Mock the config variables
-    vi.doMock('../config.js', () => ({
-      BSKY_HANDLE: 'test.bsky.social',
-      BSKY_PASSWORD: 'password',
-      OZONE_PDS: 'pds.test.com'
-    }))
+    vi.doMock("../config.js", () => ({
+      BSKY_HANDLE: "test.bsky.social",
+      BSKY_PASSWORD: "password",
+      OZONE_PDS: "pds.test.com",
+    }));
 
     // Mock the AtpAgent
-    const mockLogin = vi.fn(() => Promise.resolve())
-    const mockConstructor = vi.fn()
-    vi.doMock('@atproto/api', () => ({
+    const mockLogin = vi.fn(() => Promise.resolve());
+    const mockConstructor = vi.fn();
+    vi.doMock("@atproto/api", () => ({
       AtpAgent: class {
-        login = mockLogin
-        service: URL
+        login = mockLogin;
+        service: URL;
         constructor(options: { service: string }) {
-          mockConstructor(options)
-          this.service = new URL(options.service)
+          mockConstructor(options);
+          this.service = new URL(options.service);
         }
-      }
-    }))
+      },
+    }));
 
-    const { agent, login } = await import('../agent.js')
+    const { agent, login } = await import("../agent.js");
 
     // Check that the agent was created with the correct service URL
-    expect(mockConstructor).toHaveBeenCalledWith({ service: 'https://pds.test.com' })
-    expect(agent.service.toString()).toBe('https://pds.test.com/')
+    expect(mockConstructor).toHaveBeenCalledWith({
+      service: "https://pds.test.com",
+    });
+    expect(agent.service.toString()).toBe("https://pds.test.com/");
 
     // Check that the login function calls the mockLogin function
-    await login()
+    await login();
     expect(mockLogin).toHaveBeenCalledWith({
-      identifier: 'test.bsky.social',
-      password: 'password'
-    })
-  })
-})
+      identifier: "test.bsky.social",
+      password: "password",
+    });
+  });
+});

src/tests/limits.test.ts

···
-import { describe, it, expect } from 'vitest'
-import { limit } from '../limits.js'
+import { describe, expect, it } from "vitest";
+import { limit } from "../limits.js";
 
-describe('Rate Limiter', () => {
-  it('should limit the rate of calls', async () => {
-    const calls = []
+describe("Rate Limiter", () => {
+  it("should limit the rate of calls", async () => {
+    const calls = [];
     for (let i = 0; i < 10; i++) {
-      calls.push(limit(() => Promise.resolve(Date.now())))
+      calls.push(limit(() => Promise.resolve(Date.now())));
     }
 
-    const start = Date.now()
-    const results = await Promise.all(calls)
-    const end = Date.now()
+    const start = Date.now();
+    const results = await Promise.all(calls);
+    const end = Date.now();
 
     // With a concurrency of 4, 10 calls should take at least 2 intervals.
     // However, the interval is 30 seconds, so this test would be very slow.
     // Instead, we'll just check that the calls were successful and returned a timestamp.
-    expect(results.length).toBe(10)
+    expect(results.length).toBe(10);
     for (const result of results) {
-      expect(typeof result).toBe('number')
+      expect(typeof result).toBe("number");
     }
     // A better test would be to mock the timer and advance it, but that's more complex.
     // For now, we'll just check that the time taken is greater than 0.
-    expect(end - start).toBeGreaterThanOrEqual(0)
-  }, 40000) // Increase timeout for this test
-})
+    expect(end - start).toBeGreaterThanOrEqual(0);
+  }, 40000); // Increase timeout for this test
+});

src/tests/metrics.test.ts

···
-import { describe, it, expect } from 'vitest'
-import request from 'supertest'
-import { startMetricsServer } from '../metrics.js'
-import { Server } from 'http'
+import { Server } from "http";
+import request from "supertest";
+import { describe, expect, it } from "vitest";
+import { startMetricsServer } from "../metrics.js";
 
-describe('Metrics Server', () => {
-  let server: Server
+describe("Metrics Server", () => {
+  let server: Server;
 
   afterEach(() => {
     if (server) {
-      server.close()
+      server.close();
     }
-  })
+  });
 
-  it('should return metrics on /metrics endpoint', async () => {
-    server = startMetricsServer(0)
-    const response = await request(server).get('/metrics')
-    expect(response.status).toBe(200)
-    expect(response.headers['content-type']).toContain('text/plain')
-    expect(response.text).toContain('process_cpu_user_seconds_total')
-  })
-})
+  it("should return metrics on /metrics endpoint", async () => {
+    server = startMetricsServer(0);
+    const response = await request(server).get("/metrics");
+    expect(response.status).toBe(200);
+    expect(response.headers["content-type"]).toContain("text/plain");
+    expect(response.text).toContain("process_cpu_user_seconds_total");
+  });
+});

src/tests/moderation.test.ts

···
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { agent } from "../agent.js";
+import { logger } from "../logger.js";
 import { checkAccountLabels } from "../moderation.js";
 
 // Mock dependencies
···
 vi.mock("../limits.js", () => ({
   limit: vi.fn((fn) => fn()),
 }));
-
-import { agent } from "../agent.js";
-import { logger } from "../logger.js";
 
 describe("checkAccountLabels", () => {
   beforeEach(() => {

src/utils/getFinalUrl.test.ts

···
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { getFinalUrl } from "./getFinalUrl.js";
 
 // Mock the logger

src/utils/getLanguage.test.ts

···
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { getLanguage } from "./getLanguage.js";
 
 // Mock the logger

src/utils/homoglyph.test.ts

···
-import { describe, it, expect } from 'vitest'
-import { normalizeUnicode } from './normalizeUnicode.js'
+import { describe, expect, it } from "vitest";
+import { normalizeUnicode } from "./normalizeUnicode.js";
 
-describe('normalizeUnicode with Homoglyphs', () => {
-  it('should replace basic homoglyphs', () => {
-    expect(normalizeUnicode('h3ll0')).toBe('hello')
-    expect(normalizeUnicode('w0rld')).toBe('world')
-    expect(normalizeUnicode('p@ssword')).toBe('password')
-    expect(normalizeUnicode('1nternet')).toBe('internet')
-  })
+describe("normalizeUnicode with Homoglyphs", () => {
+  it("should replace basic homoglyphs", () => {
+    expect(normalizeUnicode("h3ll0")).toBe("hello");
+    expect(normalizeUnicode("w0rld")).toBe("world");
+    expect(normalizeUnicode("p@ssword")).toBe("password");
+    expect(normalizeUnicode("1nternet")).toBe("internet");
+  });
 
-  it('should replace Cyrillic homoglyphs', () => {
-    expect(normalizeUnicode('аpple')).toBe('apple') // 'а' is Cyrillic
-    expect(normalizeUnicode('еlеphant')).toBe('elephant') // 'е' is Cyrillic
-    expect(normalizeUnicode('оrange')).toBe('orange') // 'о' is Cyrillic
-  })
+  it("should replace Cyrillic homoglyphs", () => {
+    expect(normalizeUnicode("аpple")).toBe("apple"); // 'а' is Cyrillic
+    expect(normalizeUnicode("еlеphant")).toBe("elephant"); // 'е' is Cyrillic
+    expect(normalizeUnicode("оrange")).toBe("orange"); // 'о' is Cyrillic
+  });
 
-  it('should handle a mix of homoglyphs and regular characters', () => {
-    expect(normalizeUnicode('p@y-pаl')).toBe('pay-pal')
-    expect(normalizeUnicode('g00gl3')).toBe('google')
-  })
+  it("should handle a mix of homoglyphs and regular characters", () => {
+    expect(normalizeUnicode("p@y-pаl")).toBe("pay-pal");
+    expect(normalizeUnicode("g00gl3")).toBe("google");
+  });
 
-  it('should handle accented and other Unicode characters', () => {
-    expect(normalizeUnicode('déjà vu')).toBe('deja vu')
-    expect(normalizeUnicode('naïve')).toBe('naive')
-    expect(normalizeUnicode('façade')).toBe('facade')
-  })
+  it("should handle accented and other Unicode characters", () => {
+    expect(normalizeUnicode("déjà vu")).toBe("deja vu");
+    expect(normalizeUnicode("naïve")).toBe("naive");
+    expect(normalizeUnicode("façade")).toBe("facade");
+  });
 
-  it('should handle complex strings with multiple homoglyph types', () => {
-    const complexString = 'p@sswоrd123-еxаmple' // with Cyrillic 'о', 'а', 'е'
-    const expectedString = 'passwordize-example'
-    expect(normalizeUnicode(complexString)).toBe(expectedString)
-  })
+  it("should handle complex strings with multiple homoglyph types", () => {
+    const complexString = "p@sswоrd123-еxаmple"; // with Cyrillic 'о', 'а', 'е'
+    const expectedString = "passwordize-example";
+    expect(normalizeUnicode(complexString)).toBe(expectedString);
+  });
 
-  it('should not affect strings with no homoglyphs', () => {
-    const normalString = 'hello world'
-    expect(normalizeUnicode(normalString)).toBe(normalString)
-  })
+  it("should not affect strings with no homoglyphs", () => {
+    const normalString = "hello world";
+    expect(normalizeUnicode(normalString)).toBe(normalString);
+  });
 
-  it('should handle an empty string', () => {
-    expect(normalizeUnicode('')).toBe('')
-  })
-})
+  it("should handle an empty string", () => {
+    expect(normalizeUnicode("")).toBe("");
+  });
+});

src/utils/homoglyphs.ts

···
 
   // Confusables for 'z'
   "2": "z",
-};
+};

src/utils/normalizeUnicode.test.ts

···
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { normalizeUnicode } from "./normalizeUnicode.js";
 
 describe("normalizeUnicode", () => {

src/utils/normalizeUnicode.ts

···
 import { logger } from "../logger.js";
-
 import { homoglyphMap } from "./homoglyphs.js";
 
 /**