lihancancode/thikanaai

1. Overall shape

Thikana AI is a single Next.js 15 App Router application that combines the UI, backend endpoints, and server-side business logic in one repo. There is no separate standalone API service; instead, the backend boundary is split between server actions and route handlers under src/app.

2. Primary runtime and persistence

The application is built around Supabase for authentication, PostgreSQL data, and likely storage. Client-side code uses Supabase’s browser client, while privileged operations use dedicated server/admin clients from src/lib/supabase. The database schema is versioned in supabase/migrations, so the schema is an important architectural boundary.

3. User-facing product areas

The app is organized by top-level product flows: listings, student, landlord, alerts, chat, profile, dashboard, admin, and auth pages. This indicates a marketplace plus tenant/student utility platform, not just a simple listings site. The landing page and shared layout sit in src/app/page.tsx and src/app/layout.tsx.

4. Marketplace and listing flow

Listing browsing lives in src/app/listings, with detail pages, a new-listing flow, estimation tools, and a family-related sub-area. Reusable listing UI is in src/components/listings and src/components/cards. Listing search is exposed through src/app/api/listings/search, which is the main data-access path for marketplace discovery.

5. AI subsystem

The AI features are concentrated in src/app/api/ai/*. Separate endpoints handle listing generation, flatmate matching, neighborhood Q&A, query parsing, photo scoring, rent estimation, and trust scoring. This suggests AI is not a single model integration, but a set of narrow, task-specific services layered on top of Gemini.

6. Trust, fraud, and image analysis

Fraud detection is a dedicated subsystem. src/lib/image-hash.ts and src/app/api/utils/hash-photos support hashing photos, while src/app/actions/ai-trust-score.ts and src/app/api/ai/trust-score compute listing trust signals. The related migrations add photo_hashes and trust_scores, so image verification and score persistence are first-class parts of the architecture.

7. Student matching and shared-living flows

The student area is a separate domain with its own pages for feed, finance, matching, room shares, and a student-specific Flick API route. Supporting logic lives in src/lib/flatmate-candidates.ts, src/lib/flatmate-db.ts, and student-specific action files. This domain likely reads from Supabase, applies compatibility logic, and then surfaces matches/results in the student UI.

8. Alerts and notifications

Saved search alerts are handled by both UI and API: src/app/alerts, src/app/api/alerts/save, and src/app/api/alerts/[id]. The 005_chat_and_notifications.sql migration indicates notifications and chat are persisted features rather than purely client-side state. This area is the user-facing layer for ongoing match notifications.

9. Auth, roles, and privileged operations

Authentication is centered in src/app/auth and supported by src/lib/auth-utils.ts plus Supabase middleware/server helpers. The presence of src/app/api/make-admin and 007_admin_verification.sql shows role elevation is controlled server-side. The middleware file is important for session handling and request gating at the edge.

10. External integrations and utility layers

Gemini integration is centralized in src/lib/gemini.ts; Mapbox is abstracted in src/lib/mapbox.ts; image processing and hashing utilities support server-side media analysis. Shared UI primitives live in src/components/ui, layout/navigation in src/components/layout and src/components/shared, and animations/providers in src/lib/animations plus src/components/providers. These are supporting layers rather than domain boundaries.

11. Operational boundaries

Security and request-shaping happen at the edge via src/middleware.ts, while global presentation setup is in next.config.ts, src/app/globals.css, and Tailwind/PostCSS config. Seed data utilities in src/lib/seed-listings.ts and src/lib/seed-profiles.ts suggest local bootstrapping/testing support. Overall, the repo is a layered monolith: UI routes on top, server actions/route handlers in the middle, and Supabase/Gemini/Mapbox as external dependencies.