docit-ai 1.0.0

package/server/src/services/ai.ts

@@ -0,0 +1,99 @@
+import { GoogleGenAI } from "@google/genai";
+
+const STRATEGIC_VIEW_PROMPT = `You are a technical writer creating documentation for Project Managers.
+Focus on business value and project status. NO code snippets. Use bullet points and bold text.
+Include "What this feature enables" and a "Completeness Score" (0-100%).`;
+
+const TECHNICAL_VIEW_PROMPT = `You are a technical writer creating documentation for Developers.
+Focus on architecture and integration. Include function signatures, dependency maps, and code examples.
+Use strict Markdown with syntax highlighting.`;
+
+const PERSONAL_VIEW_PROMPT = `You are a technical writer creating documentation for Solo Developers.
+Focus on productivity. Generate To-Do lists from TODO comments and Technical Debt summaries.
+Use concise, checklist-style formatting.`;
+
+function getPromptForView(view: string): string {
+  switch (view) {
+    case "strategic":
+      return STRATEGIC_VIEW_PROMPT;
+    case "technical":
+      return TECHNICAL_VIEW_PROMPT;
+    case "personal":
+      return PERSONAL_VIEW_PROMPT;
+    default:
+      return TECHNICAL_VIEW_PROMPT;
+  }
+}
+
+export interface GenerateRequest {
+  codeSkeleton: string;
+  views?: string[];
+}
+
+export interface GenerateResult {
+  view: string;
+  content: string;
+}
+
+async function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function generateDocumentation(
+  codeSkeleton: string,
+  views: string[] = ["strategic", "technical", "personal"],
+): Promise<GenerateResult[]> {
+  const apiKey = process.env.GEMINI_API_KEY;
+  if (!apiKey) {
+    throw new Error("Gemini API key not configured");
+  }
+
+  const ai = new GoogleGenAI({ apiKey });
+  const model = "gemini-2.0-flash";
+  const results: GenerateResult[] = [];
+
+  for (const view of views) {
+    const systemPrompt = getPromptForView(view);
+
+    let lastError: Error | undefined;
+    for (let attempt = 0; attempt < 5; attempt++) {
+      try {
+        const response = await ai.models.generateContent({
+          model,
+          contents: [
+            {
+              role: "user",
+              parts: [
+                {
+                  text: `${systemPrompt}\n\n---\n\nAnalyze the following code skeleton and generate documentation:\n\n${codeSkeleton}`,
+                },
+              ],
+            },
+          ],
+        });
+
+        results.push({
+          view,
+          content: response.text ?? "",
+        });
+        break;
+      } catch (error) {
+        lastError = error as Error;
+        const status = (error as { status?: number }).status;
+
+        if (status === 503 || status === 429) {
+          const waitTime = Math.pow(2, attempt) * 1000;
+          await sleep(waitTime);
+          continue;
+        }
+        throw error;
+      }
+    }
+
+    if (results.length <= views.indexOf(view)) {
+      throw lastError ?? new Error("Failed to generate documentation");
+    }
+  }
+
+  return results;
+}

package/server/src/services/payment.ts

@@ -0,0 +1,141 @@
+import Flutterwave from "flutterwave-node-v3";
+
+const flw = new Flutterwave(
+  process.env.FLUTTERWAVE_PUBLIC_KEY ?? "",
+  process.env.FLUTTERWAVE_SECRET_KEY ?? "",
+);
+
+export interface PaymentPlan {
+  id: string;
+  name: string;
+  amount: number;
+  currency: "NGN" | "USD";
+  credits: number;
+  description: string;
+}
+
+// Subscription plans
+export const PLANS: PaymentPlan[] = [
+  {
+    id: "nigerian_dev",
+    name: "Nigerian Developer",
+    amount: 8000,
+    currency: "NGN",
+    credits: 100, // Monthly credits
+    description: "₦8,000/month - 100 credits for Nigerian developers",
+  },
+  {
+    id: "global_company",
+    name: "Global Company",
+    amount: 20,
+    currency: "USD",
+    credits: 100, // Monthly credits
+    description: "$20/month - 100 credits for global companies",
+  },
+];
+
+export function getPlanById(planId: string): PaymentPlan | undefined {
+  return PLANS.find((p) => p.id === planId);
+}
+
+export interface InitiatePaymentParams {
+  email: string;
+  userId: string;
+  planId: string;
+  redirectUrl: string;
+}
+
+export async function initiatePayment(
+  params: InitiatePaymentParams,
+): Promise<{ link: string; tx_ref: string }> {
+  const { email, userId, planId, redirectUrl } = params;
+  const plan = getPlanById(planId);
+
+  if (!plan) {
+    throw new Error("Invalid plan ID");
+  }
+
+  const tx_ref = `docit_${userId}_${Date.now()}`;
+
+  const payload = {
+    tx_ref,
+    amount: plan.amount,
+    currency: plan.currency,
+    redirect_url: redirectUrl,
+    customer: {
+      email,
+    },
+    customizations: {
+      title: "Docit Subscription",
+      description: plan.description,
+    },
+    meta: {
+      user_id: userId,
+      plan_id: planId,
+      credits: plan.credits,
+    },
+  };
+
+  try {
+    const response = await fetch("https://api.flutterwave.com/v3/payments", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${process.env.FLUTTERWAVE_SECRET_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(payload),
+    });
+
+    const data = (await response.json()) as {
+      status: string;
+      message: string;
+      data: { link: string };
+    };
+
+    if (data.status === "success") {
+      return {
+        link: data.data.link,
+        tx_ref,
+      };
+    }
+
+    throw new Error(data.message || "Failed to initiate payment");
+  } catch (error: any) {
+    console.error("Payment initiation error:", error);
+    throw new Error(error.message || "Payment initiation failed");
+  }
+}
+
+export async function verifyTransaction(transactionId: string): Promise<{
+  status: "successful" | "failed" | "pending";
+  userId?: string;
+  planId?: string;
+  credits?: number;
+  amount?: number;
+  currency?: string;
+}> {
+  const response = await flw.Transaction.verify({ id: transactionId });
+
+  if (response.status === "success" && response.data.status === "successful") {
+    const meta = response.data.meta as {
+      user_id?: string;
+      plan_id?: string;
+      credits?: number;
+    };
+
+    return {
+      status: "successful",
+      userId: meta.user_id,
+      planId: meta.plan_id,
+      credits: meta.credits,
+      amount: response.data.amount,
+      currency: response.data.currency,
+    };
+  }
+
+  return {
+    status: response.data?.status === "pending" ? "pending" : "failed",
+  };
+}
+
+export { flw };

package/server/src/types/flutterwave.d.ts

@@ -0,0 +1,60 @@
+declare module "flutterwave-node-v3" {
+  interface FlutterwaveConfig {
+    public_key: string;
+    secret_key: string;
+  }
+
+  interface ChargePayload {
+    tx_ref: string;
+    amount: number;
+    currency: string;
+    redirect_url: string;
+    payment_options?: string;
+    customer: {
+      email: string;
+      name?: string;
+      phone_number?: string;
+    };
+    customizations?: {
+      title?: string;
+      description?: string;
+      logo?: string;
+    };
+    meta?: Record<string, unknown>;
+  }
+
+  interface ChargeResponse {
+    status: string;
+    message: string;
+    data: {
+      link: string;
+      [key: string]: unknown;
+    };
+  }
+
+  interface VerifyResponse {
+    status: string;
+    message: string;
+    data: {
+      id: number;
+      tx_ref: string;
+      amount: number;
+      currency: string;
+      status: string;
+      meta: Record<string, unknown>;
+      [key: string]: unknown;
+    };
+  }
+
+  class Flutterwave {
+    constructor(publicKey: string, secretKey: string);
+    Charge: {
+      card(payload: ChargePayload): Promise<ChargeResponse>;
+    };
+    Transaction: {
+      verify(payload: { id: string }): Promise<VerifyResponse>;
+    };
+  }
+
+  export = Flutterwave;
+}

package/server/supabase_payments.sql

@@ -0,0 +1,35 @@
+-- Additional Supabase Schema for Payments
+-- Run this AFTER the initial schema
+
+-- Payment transactions table
+CREATE TABLE IF NOT EXISTS payment_transactions (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  user_id UUID REFERENCES users(id) ON DELETE CASCADE,
+  tx_ref TEXT UNIQUE NOT NULL,
+  flutterwave_id TEXT,
+  plan_id TEXT NOT NULL,
+  amount DECIMAL(10, 2) NOT NULL,
+  currency TEXT NOT NULL CHECK (currency IN ('NGN', 'USD')),
+  credits INTEGER NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'successful', 'failed', 'cancelled')),
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Indexes
+CREATE INDEX IF NOT EXISTS idx_payment_transactions_user_id ON payment_transactions(user_id);
+CREATE INDEX IF NOT EXISTS idx_payment_transactions_tx_ref ON payment_transactions(tx_ref);
+CREATE INDEX IF NOT EXISTS idx_payment_transactions_status ON payment_transactions(status);
+
+-- Updated at trigger
+DROP TRIGGER IF EXISTS payment_transactions_updated_at ON payment_transactions;
+CREATE TRIGGER payment_transactions_updated_at
+  BEFORE UPDATE ON payment_transactions
+  FOR EACH ROW
+  EXECUTE FUNCTION update_updated_at();
+
+-- RLS
+ALTER TABLE payment_transactions ENABLE ROW LEVEL SECURITY;
+
+CREATE POLICY "Service role full access on payment_transactions" ON payment_transactions
+  FOR ALL USING (true);

package/server/supabase_schema.sql

@@ -0,0 +1,90 @@
+-- Supabase Schema for Docit
+-- Run this in your Supabase SQL Editor
+
+-- Users table
+CREATE TABLE IF NOT EXISTS users (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  email TEXT UNIQUE NOT NULL,
+  password_hash TEXT NOT NULL,
+  name TEXT,
+  country TEXT,
+  credits INTEGER DEFAULT 10,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Credit transactions table
+CREATE TABLE IF NOT EXISTS credit_transactions (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  user_id UUID REFERENCES users(id) ON DELETE CASCADE,
+  amount INTEGER NOT NULL,
+  type TEXT NOT NULL CHECK (type IN ('purchase', 'usage', 'refund', 'bonus')),
+  description TEXT,
+  reference_id TEXT,
+  created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Payment transactions table (Flutterwave)
+CREATE TABLE IF NOT EXISTS payment_transactions (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  user_id UUID REFERENCES users(id) ON DELETE CASCADE,
+  tx_ref TEXT UNIQUE NOT NULL,
+  flutterwave_id TEXT,
+  plan_id TEXT NOT NULL,
+  amount DECIMAL(10, 2) NOT NULL,
+  currency TEXT NOT NULL,
+  credits INTEGER NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'successful', 'failed')),
+  created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Document generations table
+CREATE TABLE IF NOT EXISTS document_generations (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  user_id UUID REFERENCES users(id) ON DELETE CASCADE,
+  project_name VARCHAR(255) NOT NULL,
+  files_count INTEGER NOT NULL,
+  credits_used INTEGER NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Indexes
+CREATE INDEX IF NOT EXISTS idx_users_email ON users(email);
+CREATE INDEX IF NOT EXISTS idx_transactions_user_id ON credit_transactions(user_id);
+CREATE INDEX IF NOT EXISTS idx_transactions_created_at ON credit_transactions(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_payment_tx_user_id ON payment_transactions(user_id);
+CREATE INDEX IF NOT EXISTS idx_payment_tx_ref ON payment_transactions(tx_ref);
+CREATE INDEX IF NOT EXISTS idx_payment_tx_status ON payment_transactions(status);
+CREATE INDEX IF NOT EXISTS idx_doc_gen_user_id ON document_generations(user_id);
+CREATE INDEX IF NOT EXISTS idx_doc_gen_created_at ON document_generations(created_at DESC);
+
+-- Updated at trigger
+CREATE OR REPLACE FUNCTION update_updated_at()
+RETURNS TRIGGER AS $$
+BEGIN
+  NEW.updated_at = NOW();
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+DROP TRIGGER IF EXISTS users_updated_at ON users;
+CREATE TRIGGER users_updated_at
+  BEFORE UPDATE ON users
+  FOR EACH ROW
+  EXECUTE FUNCTION update_updated_at();
+
+-- Row Level Security (optional, for direct client access)
+ALTER TABLE users ENABLE ROW LEVEL SECURITY;
+ALTER TABLE credit_transactions ENABLE ROW LEVEL SECURITY;
+ALTER TABLE payment_transactions ENABLE ROW LEVEL SECURITY;
+
+-- Service role can access all rows
+CREATE POLICY "Service role full access on users" ON users
+  FOR ALL USING (true);
+
+CREATE POLICY "Service role full access on transactions" ON credit_transactions
+  FOR ALL USING (true);
+
+CREATE POLICY "Service role full access on payments" ON payment_transactions
+  FOR ALL USING (true);
+

package/server/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "module": "nodenext",
+    "target": "esnext",
+    "lib": ["esnext"],
+    "types": ["node"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/server/vercel.json

@@ -0,0 +1,15 @@
+{
+  "version": 2,
+  "builds": [
+    {
+      "src": "dist/index.js",
+      "use": "@vercel/node"
+    }
+  ],
+  "routes": [
+    {
+      "src": "/(.*)",
+      "dest": "dist/index.js"
+    }
+  ]
+}

package/server/verify_dashboard.ts

@@ -0,0 +1,126 @@
+import fetch from "node-fetch";
+
+const BASE_URL = "http://localhost:3001/api";
+
+async function test() {
+  console.log("🚀 Starting verification...");
+
+  // 1. Health check
+  const health = await fetch(`http://localhost:3001/health`).then((r) =>
+    r.json(),
+  );
+  console.log("✅ Health:", health);
+
+  // 2. Register/Login
+  const email = `test_${Date.now()}@example.com`;
+  const password = "password123";
+
+  console.log(`👤 Registering user ${email}...`);
+  const registerRes = await fetch(`${BASE_URL}/auth/register`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      email,
+      password,
+      name: "Test User",
+      country: "Nigeria",
+    }),
+  });
+
+  const authBody: any = await registerRes.json();
+  if (!registerRes.ok) {
+    console.error("❌ Registration failed:", authBody);
+    return;
+  }
+
+  const token = authBody.token;
+  const headers = { Authorization: `Bearer ${token}` };
+  console.log("✅ Registered & Logged in");
+
+  // 3. Test Auth Me (Check for new fields)
+  const me: any = await fetch(`${BASE_URL}/auth/me`, { headers }).then((r) =>
+    r.json(),
+  );
+  if (me.user.name && me.user.createdAt) {
+    console.log("✅ /auth/me returns new fields");
+  } else {
+    console.error("❌ /auth/me missing fields:", me);
+  }
+
+  // 4. Test Dashboard Stats
+  const stats = await fetch(`${BASE_URL}/dashboard/stats`, { headers }).then(
+    (r) => r.json(),
+  );
+  console.log("📊 Stats:", stats);
+
+  // 5. Test Generate (to create data for dashboard)
+  console.log("📝 Generating fake document...");
+  const genRes = await fetch(`${BASE_URL}/generate`, {
+    method: "POST",
+    headers: { ...headers, "Content-Type": "application/json" },
+    body: JSON.stringify({
+      codeSkeleton: "console.log('hello')",
+      views: ["technical"],
+      fileCount: 2,
+      projectName: "Test Project",
+    }),
+  });
+
+  // Note: Generate calls main AI service. If it fails due to keys/etc, we handle logic,
+  // but importantly we want to see if it hits our database logic if successful.
+  // Actually, without AI keys configured this might fail.
+  // Let's manually insert data via direct DB call or just expect empty stats first.
+
+  if (genRes.ok) {
+    console.log("✅ Generation successful");
+    // Check stats again to see update
+    const stats2 = await fetch(`${BASE_URL}/dashboard/stats`, { headers }).then(
+      (r) => r.json(),
+    );
+    console.log("📊 Stats after generation:", stats2);
+  } else {
+    console.log(
+      "⚠️ Generation skipped/failed (expected if AI keys missing):",
+      await genRes.json(),
+    );
+    // We can't easily verify the DB write if generation fails, but we can verify the other endpoints return empty structures
+  }
+
+  // 6. Test Dashboard Activity
+  const activity: any = await fetch(`${BASE_URL}/dashboard/activity`, {
+    headers,
+  }).then((r) => r.json());
+  console.log("activity:", activity);
+  if (Array.isArray(activity.activities)) {
+    console.log("✅ Activity endpoint returns array");
+  }
+
+  // 7. Test Dashboard Usage
+  const usage: any = await fetch(`${BASE_URL}/dashboard/usage`, {
+    headers,
+  }).then((r) => r.json());
+  console.log("usage:", usage);
+  if (Array.isArray(usage.data)) {
+    console.log("✅ Usage endpoint returns data array");
+  }
+
+  // 8. Test Dashboard Documents
+  const docs: any = await fetch(`${BASE_URL}/dashboard/documents`, {
+    headers,
+  }).then((r) => r.json());
+  console.log("documents:", docs);
+  if (Array.isArray(docs.documents)) {
+    console.log("✅ Documents endpoint returns array");
+  }
+
+  // 9. Test Dashboard Billing
+  const billing: any = await fetch(`${BASE_URL}/dashboard/billing`, {
+    headers,
+  }).then((r) => r.json());
+  console.log("billing:", billing);
+  if (billing.creditBalance !== undefined) {
+    console.log("✅ Billing endpoint returns info");
+  }
+}
+
+test().catch(console.error);

package/src/ai/engine.ts

@@ -0,0 +1,103 @@
+import { GoogleGenAI } from "@google/genai";
+import { getPromptForView, type ViewType } from "./prompts.js";
+
+/**
+ * AI Engine Module
+ * Orchestrates calls to the Gemini LLM.
+ */
+
+export interface DocumentationResult {
+  view: ViewType;
+  content: string;
+}
+
+export interface EngineConfig {
+  apiKey: string;
+  model?: string | undefined;
+  maxRetries?: number | undefined;
+}
+
+async function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export class DocitEngine {
+  private ai: GoogleGenAI;
+  private model: string;
+  private maxRetries: number;
+
+  constructor(config: EngineConfig) {
+    this.ai = new GoogleGenAI({ apiKey: config.apiKey });
+    this.model = config.model ?? "gemini-2.0-flash";
+    this.maxRetries = config.maxRetries ?? 5;
+  }
+
+  async generateDocumentation(
+    codeSkeleton: string,
+    view: ViewType,
+  ): Promise<DocumentationResult> {
+    const systemPrompt = getPromptForView(view);
+
+    let lastError: Error | undefined;
+
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        const response = await this.ai.models.generateContent({
+          model: this.model,
+          contents: [
+            {
+              role: "user",
+              parts: [
+                {
+                  text: `${systemPrompt}\n\n---\n\nAnalyze the following code skeleton and generate documentation:\n\n${codeSkeleton}`,
+                },
+              ],
+            },
+          ],
+        });
+
+        const content = response.text ?? "";
+
+        return {
+          view,
+          content,
+        };
+      } catch (error) {
+        lastError = error as Error;
+        const status = (error as { status?: number }).status;
+
+        // Retry on 503 (overloaded) or 429 (rate limit)
+        if (status === 503 || status === 429) {
+          const waitTime = Math.pow(2, attempt) * 1000; // Exponential backoff
+          console.log(
+            `   ⏳ Model overloaded, retrying in ${waitTime / 1000}s...`,
+          );
+          await sleep(waitTime);
+          continue;
+        }
+
+        // Don't retry other errors
+        throw error;
+      }
+    }
+
+    throw lastError ?? new Error("Max retries exceeded");
+  }
+
+  async generateAllViews(codeSkeleton: string): Promise<DocumentationResult[]> {
+    const views: ViewType[] = ["strategic", "technical", "personal"];
+    const results: DocumentationResult[] = [];
+
+    for (const view of views) {
+      console.log(`   📄 Generating ${view} view...`);
+      const result = await this.generateDocumentation(codeSkeleton, view);
+      results.push(result);
+    }
+
+    return results;
+  }
+}
+
+export function createEngine(apiKey: string): DocitEngine {
+  return new DocitEngine({ apiKey });
+}