Migrates to use Masa

.clinerules/repository-analysis-workflow.md

@@ -0,0 +1,50 @@
+## Brief overview
+This rule outlines a comprehensive workflow for Cline to analyze a software repository. The objective is to thoroughly understand its architecture, data flows, and key components, subsequently producing markdown documentation and actionable recommendations for improvement and standardization. This process is designed to be adaptable to various codebases.
+
+## Analysis Workflow Steps
+-   **Initial Information Gathering**:
+    -   Begin with a top-level overview of the repository structure. This can be achieved using `list_files` or by reviewing an initial file manifest if provided by the system.
+    -   Identify key directories (e.g., `src`, `services`, `db`, `routes`) and primary entry points (e.g., `index.ts`, `app.ts`, main schema files).
+-   **Iterative Deep Dive**:
+    -   Systematically request and analyze core files using the `read_file` tool. Start with foundational layers (e.g., database schemas, ORM setup, core utilities) and progress towards higher-level components (e.g., repositories, services, API controllers, application bootstrap).
+    -   Pay close attention to `import` and `export` statements to map dependencies and understand relationships between different modules and files.
+    -   For complex systems, analyze components layer by layer (e.g., data access -> business logic -> API presentation).
+-   **Understanding Key Components**:
+    -   **Data Layer**: Analyze database schema definitions, ORM configurations (if any), repository patterns, and data model structures (e.g., Zod schemas for JSONB columns).
+    -   **Service Layer**: For each service, determine its primary purpose, public methods (including their arguments and return types if inferable), key dependencies (other services, repositories), and how it encapsulates business logic.
+    -   **API Layer**: Examine API route definitions, how requests are handled, request/response validation mechanisms, authentication/authorization middleware, and the connection between routes and services.
+    -   **Configuration Management**: Understand how application settings (global, per-feed, plugin-specific) are loaded and accessed (e.g., from files, environment variables, or database).
+    -   **Plugin System (if applicable)**: Analyze how plugins are loaded, managed, and integrated (e.g., module federation, lifecycle methods).
+    -   **Application Setup & Entry Point**: Review how the application is initialized, middleware is configured, and the server is started.
+-   **Identifying Patterns and Flows**:
+    -   Trace 2-3 critical data flows through the application (e.g., content ingestion, user authentication, request processing for a key feature).
+    -   Identify common design patterns employed (e.g., Service-Oriented Architecture, Repository Pattern, Dependency Injection via ServiceProvider).
+    -   Note conventions for naming, styling, and project structure.
+
+## Documentation Output
+-   **Format**: Markdown.
+-   **Content**:
+    -   High-level architecture overview (potentially with a Mermaid diagram).
+    -   Detailed breakdown of key layers/components (Data, Service, API, Config, Plugins, etc.).
+    -   Description of major data flows.
+    -   List of identified patterns and conventions.
+    -   Summary of each service's purpose, key methods (with arguments if possible), and its primary dependencies.
+    -   Overview of the database schema.
+-   **File Structure**: A main analysis document, potentially linking to more detailed documents for specific complex areas if necessary.
+
+## Recommendations Output
+-   **Format**: Markdown, potentially separate files for different categories of recommendations (e.g., `config_recommendations.md`, `rbac_recommendations.md`, `code_cleanup.md`).
+-   **Content**:
+    -   **Consolidation & Cleanup**: Identify redundant code, areas for simplification, and opportunities to consolidate similar functionalities.
+    -   **Better Strategy**: Suggest improvements to architectural patterns, data models, or service interactions.
+    -   **Files to Delete/Refactor**: Pinpoint obsolete files or those needing significant rework.
+    -   **Standardization**: Propose ways to standardize coding practices, naming conventions, error handling, dependency management, etc., across the codebase.
+    -   **Cross-Codebase Consistency**: Where applicable, recommend patterns or approaches observed in the analyzed repository that could be beneficially applied to other codebases for consistency.
+    -   **Specific Goals**: If the user has specific goals (e.g., "move all config to DB"), recommendations should directly address how to achieve these.
+-   **Actionability**: Recommendations should be specific and provide clear instructions or examples where possible.
+
+## Interaction Style during Analysis
+-   **Iterative Updates**: Provide regular updates on the learning progress and understanding of different components.
+-   **Clarification**: Use `ask_followup_question` if critical information is missing or ambiguous.
+-   **Tool Usage**: Primarily use `read_file` for information gathering. Use `list_files` or `search_files` if the initial file manifest is insufficient or specific patterns need to be located.
+-   **User Confirmation**: After analyzing a significant chunk or a key component, summarize understanding before moving to the next, to ensure alignment. (This can be done via `plan_mode_respond`).

.github/workflows/deployment.yml

@@ -14,7 +14,7 @@ jobs:
 
     strategy:
       matrix:
-        platform: [ linux/amd64 ]
+        platform: [linux/amd64]
 
     steps:
       - name: Checkout code
@@ -43,4 +43,3 @@ jobs:
           platforms: ${{ matrix.platform }}
           push: true
           tags: ghcr.io/${{ env.REPO }}:${{ github.sha }}
-

.github/workflows/near-rewards.yml

@@ -1,10 +1,10 @@
 name: NEAR Protocol Rewards Tracking
 on:
   schedule:
-    - cron: '0 */12 * * *'  # Every 12 hours
-  workflow_dispatch:        # Manual trigger
+    - cron: "0 */12 * * *" # Every 12 hours
+  workflow_dispatch: # Manual trigger
   push:
-    branches: [ main ]     # Start on main branch updates
+    branches: [main] # Start on main branch updates
 
 jobs:
   calculate-rewards:
@@ -17,12 +17,12 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
         with:
-          node-version: '18'
+          node-version: "18"
 
       - name: Calculate Rewards
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           GITHUB_REPO: ${{ github.repository }}
         run: |
           npm install -g near-protocol-rewards@latest
-          near-protocol-rewards calculate
+          near-protocol-rewards calculate

.vscode/settings.json

@@ -0,0 +1,16 @@
+{
+  "cSpell.words": [
+    "crowdsource",
+    "ilhagirl",
+    "jpollock",
+    "karmaticacid",
+    "morica",
+    "murica",
+    "oklch",
+    "plugrel",
+    "plungrel",
+    "POTLOCK",
+    "SCURATE",
+    "yegorgolovnia"
+  ]
+}

Dockerfile

@@ -1,8 +1,6 @@
 # Base stage with common dependencies
-FROM node:18-alpine AS base
+FROM oven/bun:latest AS base
 
-# Install pnpm
-RUN npm install -g pnpm turbo
 
 # Builder stage for pruning the monorepo
 FROM base AS pruner
@@ -21,22 +19,21 @@ WORKDIR /app
 
 # Copy pruned package.json files and workspace config
 COPY --from=pruner /app/out/json/ .
-COPY --from=pruner /app/out/pnpm-lock.yaml ./pnpm-lock.yaml
+# COPY --from=pruner /app/out/bun.lockb ./bun.lockb # bun.lockb should be generated by bun install
 COPY --from=pruner /app/turbo.json ./turbo.json
-COPY --from=pruner /app/pnpm-workspace.yaml ./pnpm-workspace.yaml
 
-# Install dependencies using pnpm workspaces
-RUN pnpm install --frozen-lockfile
+# Install dependencies using bun workspaces
+RUN bun install --frozen-lockfile
 
 # Copy source code from pruned monorepo
 COPY --from=pruner /app/out/full/ .
 
 # Build the application using turbo (which will respect the dependencies in turbo.json)
 ENV NODE_ENV="production"
-RUN pnpm run build
+RUN bun run build
 
 # Production stage
-FROM node:18-alpine AS production
+FROM oven/bun:latest AS production
 WORKDIR /app
 
 # Create a non-root user for security
@@ -48,16 +45,13 @@ COPY --from=builder --chown=app:app /app/backend/package.json ./backend/package.
 COPY --from=builder --chown=app:app /app/backend/drizzle.config.ts ./backend/drizzle.config.ts
 COPY --from=builder --chown=app:app /app/backend/src/services/db/migrations ./backend/src/services/db/migrations
 COPY --from=builder --chown=app:app /app/backend/src/services/db/schema.ts ./backend/src/services/db/schema.ts
+COPY --from=builder --chown=app:app /app/backend/src/services/db/schema ./backend/src/services/db/schema
 COPY --from=builder --chown=app:app /app/package.json ./
-COPY --from=builder --chown=app:app /app/pnpm-lock.yaml ./
-COPY --from=builder --chown=app:app /app/pnpm-workspace.yaml ./pnpm-workspace.yaml
+COPY --from=builder --chown=app:app /app/bun.lockb ./bun.lockb
 COPY --chown=app:app curate.config.json ./
 
-# Install pnpm
-RUN npm install -g pnpm
-
-# Install only production dependencies
-RUN cd backend && pnpm install --prod --frozen-lockfile
+# Install only production dependencies for the backend
+RUN cd backend && bun install --production
 
 # Use the non-root user
 USER app
@@ -66,4 +60,4 @@ USER app
 EXPOSE 3000
 
 # Start the application
-CMD ["pnpm", "run", "--dir", "backend", "start"]
+CMD ["bun", "run", "--cwd", "backend", "start"]

README.md

@@ -74,31 +74,31 @@ graph TD
         Twitter["Twitter Source Plugin"]
         style Twitter color:black
     end
-    
+
     %% Submission Processing
     subgraph Submission["Submission Processing"]
         SubmissionService["Submission Service"]
         Moderation["Curator Moderation"]
         style SubmissionService color:black
         style Moderation color:black
     end
-    
+
     %% Content Processing
     subgraph Processing["Content Processing"]
         ProcessorService["Processor Service"]
         GlobalTransform["Global Transformations"]
         style ProcessorService color:black
         style GlobalTransform color:black
     end
-    
+
     %% Distribution
     subgraph Distribution["Distribution"]
         DistributionService["Distribution Service"]
         DistTransform["Distributor-specific Transforms"]
         style DistributionService color:black
         style DistTransform color:black
     end
-    
+
     %% Distributor Plugins
     subgraph Distributors["Distributor Plugins"]
         Telegram["Telegram"]
@@ -110,7 +110,7 @@ graph TD
         style Notion color:black
         style Supabase color:black
     end
-    
+
     %% Flow connections
     Sources --> SubmissionService
     SubmissionService --> Moderation
@@ -119,12 +119,12 @@ graph TD
     GlobalTransform --> DistributionService
     DistributionService --> DistTransform
     DistTransform --> Distributors
-    
+
     %% Styling
     classDef service fill:#f9f,stroke:#333,stroke-width:2px
     classDef plugin fill:#bbf,stroke:#333,stroke-width:1px
     classDef process fill:#bfb,stroke:#333,stroke-width:1px
-    
+
     class SubmissionService,ProcessorService,DistributionService service
     class Twitter,Telegram,RSS,Notion,Supabase plugin
     class Moderation,GlobalTransform,DistTransform process
@@ -133,6 +133,7 @@ graph TD
 ### Key Components
 
 - **[Frontend](./frontend/README.md)**
+
   - React-based web interface
   - Built with RSBuild and Tailwind CSS
   - Handles user interactions and submissions