@locusai/sdk 0.4.6 → 0.4.10

package/dist/agent/artifact-syncer.js

@@ -1,77 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, } from "node:fs";
-import { join } from "node:path";
-import { getLocusPath } from "../core/config.js";
-/**
- * Handles syncing local artifacts to the platform
- */
-export class ArtifactSyncer {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    async getOrCreateArtifactsGroup() {
-        try {
-            const groups = await this.deps.client.docs.listGroups(this.deps.workspaceId);
-            const artifactsGroup = groups.find((g) => g.name === "Artifacts");
-            if (artifactsGroup) {
-                return artifactsGroup.id;
-            }
-            // Create the Artifacts group
-            const newGroup = await this.deps.client.docs.createGroup(this.deps.workspaceId, {
-                name: "Artifacts",
-                order: 999, // Place at the end
-            });
-            this.deps.log("Created 'Artifacts' group for agent-generated docs", "info");
-            return newGroup.id;
-        }
-        catch (error) {
-            this.deps.log(`Failed to get/create Artifacts group: ${error}`, "error");
-            throw error;
-        }
-    }
-    async sync() {
-        const artifactsDir = getLocusPath(this.deps.projectPath, "artifactsDir");
-        if (!existsSync(artifactsDir)) {
-            mkdirSync(artifactsDir, { recursive: true });
-            return;
-        }
-        try {
-            const files = readdirSync(artifactsDir);
-            if (files.length === 0)
-                return;
-            this.deps.log(`Syncing ${files.length} artifacts to server...`, "info");
-            // Get or create the Artifacts group
-            const artifactsGroupId = await this.getOrCreateArtifactsGroup();
-            // Get existing docs to check for updates
-            const existingDocs = await this.deps.client.docs.list(this.deps.workspaceId);
-            for (const file of files) {
-                const filePath = join(artifactsDir, file);
-                if (statSync(filePath).isFile()) {
-                    const content = readFileSync(filePath, "utf-8");
-                    const title = file.replace(/\.md$/, "").trim();
-                    if (!title)
-                        continue;
-                    const existing = existingDocs.find((d) => d.title === title);
-                    if (existing) {
-                        if (existing.content !== content ||
-                            existing.groupId !== artifactsGroupId) {
-                            await this.deps.client.docs.update(existing.id, this.deps.workspaceId, { content, groupId: artifactsGroupId });
-                            this.deps.log(`Updated artifact: ${file}`, "success");
-                        }
-                    }
-                    else {
-                        await this.deps.client.docs.create(this.deps.workspaceId, {
-                            title,
-                            content,
-                            groupId: artifactsGroupId,
-                        });
-                        this.deps.log(`Created artifact: ${file}`, "success");
-                    }
-                }
-            }
-        }
-        catch (error) {
-            this.deps.log(`Failed to sync artifacts: ${error}`, "error");
-        }
-    }
-}

package/dist/agent/codebase-indexer-service.js

@@ -1,55 +0,0 @@
-import { CodebaseIndexer } from "../core/indexer.js";
-/**
- * Handles codebase indexing with AI analysis
- */
-export class CodebaseIndexerService {
-    deps;
-    indexer;
-    constructor(deps) {
-        this.deps = deps;
-        this.indexer = new CodebaseIndexer(deps.projectPath);
-    }
-    async reindex() {
-        try {
-            this.deps.log("Reindexing codebase...", "info");
-            const index = await this.indexer.index((msg) => this.deps.log(msg, "info"), async (tree) => {
-                const prompt = `You are a codebase analysis expert. Analyze the file tree and extract:
-1. Key symbols (classes, functions, types) and their locations
-2. Responsibilities of each directory/file
-3. Overall project structure
-
-Analyze this file tree and provide a JSON response with:
-- "symbols": object mapping symbol names to file paths (array)
-- "responsibilities": object mapping paths to brief descriptions
-
-File tree:
-${tree}
-
-Return ONLY valid JSON, no markdown formatting.`;
-                let response;
-                if (this.deps.anthropicClient) {
-                    // Use Anthropic SDK with caching for faster indexing
-                    response = await this.deps.anthropicClient.run({
-                        systemPrompt: "You are a codebase analysis expert specialized in extracting structure and symbols from file trees.",
-                        userPrompt: prompt,
-                    });
-                }
-                else {
-                    // Fallback to Claude CLI
-                    response = await this.deps.claudeRunner.run(prompt, true);
-                }
-                // Extract JSON from response (handle markdown code blocks)
-                const jsonMatch = response.match(/\{[\s\S]*\}/);
-                if (jsonMatch) {
-                    return JSON.parse(jsonMatch[0]);
-                }
-                return { symbols: {}, responsibilities: {}, lastIndexed: "" };
-            });
-            this.indexer.saveIndex(index);
-            this.deps.log("Codebase reindexed successfully", "success");
-        }
-        catch (error) {
-            this.deps.log(`Failed to reindex codebase: ${error}`, "error");
-        }
-    }
-}

package/dist/agent/index.js

@@ -1,5 +0,0 @@
-export { ArtifactSyncer } from "./artifact-syncer.js";
-export { CodebaseIndexerService } from "./codebase-indexer-service.js";
-export { SprintPlanner } from "./sprint-planner.js";
-export { TaskExecutor } from "./task-executor.js";
-export { AgentWorker } from "./worker.js";

package/dist/agent/sprint-planner.js

@@ -1,68 +0,0 @@
-/**
- * Handles sprint planning and mindmap generation
- */
-export class SprintPlanner {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    async planSprint(sprint, tasks) {
-        this.deps.log(`Planning sprint: ${sprint.name}`, "info");
-        try {
-            const taskList = tasks
-                .map((t) => `- [${t.id}] ${t.title}: ${t.description || "No description"}`)
-                .join("\n");
-            let plan;
-            if (this.deps.anthropicClient) {
-                // Use Anthropic SDK with caching for faster planning
-                const systemPrompt = `You are an expert project manager and lead engineer specialized in sprint planning and task prioritization.`;
-                const userPrompt = `# Sprint Planning: ${sprint.name}
-
-## Tasks
-${taskList}
-
-## Instructions
-1. Analyze dependencies between these tasks.
-2. Prioritize them for the most efficient execution.
-3. Create a mindmap (in Markdown or Mermaid format) that visualizes the sprint structure.
-4. Output your final plan. The plan should clearly state the order of execution.
-
-**IMPORTANT**: 
-- Do NOT create any files on the filesystem during this planning phase. 
-- Avoid using absolute local paths (e.g., /Users/...) in your output. Use relative paths starting from the project root if necessary.
-- Your output will be saved as the official sprint mindmap on the server.`;
-                plan = await this.deps.anthropicClient.run({
-                    systemPrompt,
-                    userPrompt,
-                });
-            }
-            else {
-                // Fallback to Claude CLI
-                const planningPrompt = `# Sprint Planning: ${sprint.name}
-
-You are an expert project manager and lead engineer. You need to create a mindmap and execution plan for the following tasks in this sprint.
-
-## Tasks
-${taskList}
-
-## Instructions
-1. Analyze dependencies between these tasks.
-2. Prioritize them for the most efficient execution.
-3. Create a mindmap (in Markdown or Mermaid format) that visualizes the sprint structure.
-4. Output your final plan. The plan should clearly state the order of execution.
-
-**IMPORTANT**: 
-- Do NOT create any files on the filesystem during this planning phase. 
-- Avoid using absolute local paths (e.g., /Users/...) in your output. Use relative paths starting from the project root if necessary.
-- Your output will be saved as the official sprint mindmap on the server.`;
-                plan = await this.deps.claudeRunner.run(planningPrompt, true);
-            }
-            this.deps.log("Sprint mindmap generated and posted to server.", "success");
-            return plan;
-        }
-        catch (error) {
-            this.deps.log(`Sprint planning failed: ${error}`, "error");
-            return sprint.mindmap || "";
-        }
-    }
-}

package/dist/agent/task-executor.js

@@ -1,60 +0,0 @@
-import { PromptBuilder } from "../core/prompt-builder.js";
-/**
- * Handles task execution with two-phase approach (planning + execution)
- */
-export class TaskExecutor {
-    deps;
-    promptBuilder;
-    constructor(deps) {
-        this.deps = deps;
-        this.promptBuilder = new PromptBuilder(deps.projectPath);
-    }
-    updateSprintPlan(sprintPlan) {
-        this.deps.sprintPlan = sprintPlan;
-    }
-    async execute(task) {
-        this.deps.log(`Executing: ${task.title}`, "info");
-        let basePrompt = await this.promptBuilder.build(task);
-        if (this.deps.sprintPlan) {
-            basePrompt = `## Sprint Context\n${this.deps.sprintPlan}\n\n${basePrompt}`;
-        }
-        try {
-            let plan = "";
-            if (this.deps.anthropicClient) {
-                // Phase 1: Planning (using Anthropic SDK with caching)
-                this.deps.log("Phase 1: Planning (Anthropic SDK)...", "info");
-                // Build cacheable context blocks
-                const cacheableContext = [basePrompt];
-                plan = await this.deps.anthropicClient.run({
-                    systemPrompt: "You are an expert software engineer. Analyze the task carefully and create a detailed implementation plan.",
-                    cacheableContext,
-                    userPrompt: "## Phase 1: Planning\nAnalyze and create a detailed plan for THIS SPECIFIC TASK. Do NOT execute changes yet.",
-                });
-            }
-            else {
-                this.deps.log("Skipping Phase 1: Planning (No Anthropic API Key)...", "info");
-            }
-            // Phase 2: Execution (always using Claude CLI for agentic tools)
-            this.deps.log("Starting Execution...", "info");
-            let executionPrompt = basePrompt;
-            if (plan) {
-                executionPrompt += `\n\n## Phase 2: Execution\nBased on the plan, execute the task:\n\n${plan}`;
-            }
-            else {
-                executionPrompt += `\n\n## Execution\nExecute the task directly.`;
-            }
-            executionPrompt += `\n\nWhen finished, output: <promise>COMPLETE</promise>`;
-            const output = await this.deps.claudeRunner.run(executionPrompt);
-            const success = output.includes("<promise>COMPLETE</promise>");
-            return {
-                success,
-                summary: success
-                    ? "Task completed by Claude"
-                    : "Claude did not signal completion",
-            };
-        }
-        catch (error) {
-            return { success: false, summary: `Error: ${error}` };
-        }
-    }
-}

package/dist/ai/anthropic-client.js

@@ -1,70 +0,0 @@
-import Anthropic from "@anthropic-ai/sdk";
-import { DEFAULT_MODEL } from "../core/config.js";
-/**
- * Anthropic Client with Prompt Caching Support
- *
- * This client wraps the official Anthropic SDK and adds support for
- * prompt caching to dramatically reduce latency and costs for repeated
- * context (like codebase indexes, CLAUDE.md, etc.)
- */
-export class AnthropicClient {
-    client;
-    model;
-    constructor(config) {
-        this.client = new Anthropic({
-            apiKey: config.apiKey,
-        });
-        this.model = config.model || DEFAULT_MODEL;
-    }
-    /**
-     * Run a prompt with optional caching for large context blocks
-     *
-     * @param options - Prompt configuration with cacheable context
-     * @returns The generated text response
-     */
-    async run(options) {
-        const { systemPrompt, cacheableContext = [], userPrompt } = options;
-        // Build system message with cache breakpoints
-        const systemContent = [];
-        if (systemPrompt) {
-            systemContent.push({
-                type: "text",
-                text: systemPrompt,
-            });
-        }
-        // Add each cacheable context block with cache_control
-        for (let i = 0; i < cacheableContext.length; i++) {
-            const isLast = i === cacheableContext.length - 1;
-            systemContent.push({
-                type: "text",
-                text: cacheableContext[i],
-                // Only the last block gets the cache breakpoint
-                ...(isLast && {
-                    cache_control: { type: "ephemeral" },
-                }),
-            });
-        }
-        const response = await this.client.messages.create({
-            model: this.model,
-            max_tokens: 8000,
-            system: systemContent,
-            messages: [
-                {
-                    role: "user",
-                    content: userPrompt,
-                },
-            ],
-        });
-        // Extract text from response
-        const textBlocks = response.content.filter((block) => block.type === "text");
-        return textBlocks.map((block) => block.text).join("\n");
-    }
-    /**
-     * Simple run without caching (for short prompts)
-     */
-    async runSimple(prompt) {
-        return this.run({
-            userPrompt: prompt,
-        });
-    }
-}

package/dist/ai/claude-runner.js

@@ -1,71 +0,0 @@
-import { spawn } from "node:child_process";
-import { DEFAULT_MODEL } from "../core/config.js";
-export class ClaudeRunner {
-    projectPath;
-    model;
-    constructor(projectPath, model = DEFAULT_MODEL) {
-        this.projectPath = projectPath;
-        this.model = model;
-    }
-    async run(prompt, _isPlanning = false) {
-        const maxRetries = 3;
-        let lastError = null;
-        for (let attempt = 1; attempt <= maxRetries; attempt++) {
-            try {
-                return await this.executeRun(prompt);
-            }
-            catch (error) {
-                const err = error;
-                lastError = err;
-                const isLastAttempt = attempt === maxRetries;
-                if (!isLastAttempt) {
-                    const delay = Math.pow(2, attempt) * 1000; // 2s, 4s, 8s
-                    console.warn(`Claude CLI attempt ${attempt} failed: ${err.message}. Retrying in ${delay}ms...`);
-                    await new Promise((resolve) => setTimeout(resolve, delay));
-                }
-            }
-        }
-        throw lastError || new Error("Claude CLI failed after multiple attempts");
-    }
-    executeRun(prompt) {
-        return new Promise((resolve, reject) => {
-            const args = [
-                "--dangerously-skip-permissions",
-                "--print",
-                "--model",
-                this.model,
-            ];
-            const claude = spawn("claude", args, {
-                cwd: this.projectPath,
-                stdio: ["pipe", "pipe", "pipe"],
-                env: process.env,
-                shell: true,
-            });
-            let output = "";
-            let errorOutput = "";
-            claude.stdout.on("data", (data) => {
-                output += data.toString();
-                // Only write to stdout if we're not retrying or if logic dictates
-                // process.stdout.write(data.toString());
-            });
-            claude.stderr.on("data", (data) => {
-                errorOutput += data.toString();
-                // process.stderr.write(data.toString());
-            });
-            claude.on("error", (err) => reject(new Error(`Failed to start Claude CLI (shell: true): ${err.message}. Please ensure the 'claude' command is available in your PATH.`)));
-            claude.on("close", (code) => {
-                if (code === 0)
-                    resolve(output);
-                else {
-                    const detail = errorOutput.trim();
-                    const message = detail
-                        ? `Claude CLI error (exit code ${code}): ${detail}`
-                        : `Claude CLI exited with code ${code}. Please ensure the Claude CLI is installed and you are logged in (run 'claude' manually to check).`;
-                    reject(new Error(message));
-                }
-            });
-            claude.stdin.write(prompt);
-            claude.stdin.end();
-        });
-    }
-}

package/dist/ai/index.js

@@ -1,2 +0,0 @@
-export { AnthropicClient } from "./anthropic-client.js";
-export { ClaudeRunner } from "./claude-runner.js";

package/dist/core/config.js

@@ -1,15 +0,0 @@
-import { join } from "node:path";
-export const DEFAULT_MODEL = "sonnet";
-export const LOCUS_CONFIG = {
-    dir: ".locus",
-    configFile: "config.json",
-    indexFile: "codebase-index.json",
-    contextFile: "CLAUDE.md",
-    artifactsDir: "artifacts",
-};
-export function getLocusPath(projectPath, fileName) {
-    if (fileName === "contextFile") {
-        return join(projectPath, LOCUS_CONFIG.contextFile);
-    }
-    return join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG[fileName]);
-}

package/dist/core/index.js

@@ -1,3 +0,0 @@
-export { DEFAULT_MODEL, getLocusPath, LOCUS_CONFIG } from "./config.js";
-export { CodebaseIndexer } from "./indexer.js";
-export { PromptBuilder } from "./prompt-builder.js";

package/dist/core/indexer.js

@@ -1,113 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { globby } from "globby";
-export class CodebaseIndexer {
-    projectPath;
-    indexPath;
-    constructor(projectPath) {
-        this.projectPath = projectPath;
-        this.indexPath = join(projectPath, ".locus", "codebase-index.json");
-    }
-    /**
-     * Generates a codebase index by providing the entire file tree to an AI summarizer.
-     * This is much more efficient than per-file indexing for large projects.
-     */
-    async index(onProgress, treeSummarizer) {
-        if (!treeSummarizer) {
-            throw new Error("A treeSummarizer is required for this indexing method.");
-        }
-        if (onProgress)
-            onProgress("Generating file tree...");
-        // 1. Get a comprehensive but clean file tree
-        const gitmodulesPath = join(this.projectPath, ".gitmodules");
-        const submoduleIgnores = [];
-        if (existsSync(gitmodulesPath)) {
-            try {
-                const content = readFileSync(gitmodulesPath, "utf-8");
-                const lines = content.split("\n");
-                for (const line of lines) {
-                    const match = line.match(/^\s*path\s*=\s*(.*)$/);
-                    const path = match?.[1]?.trim();
-                    if (path) {
-                        submoduleIgnores.push(`${path}/**`);
-                        submoduleIgnores.push(`**/${path}/**`);
-                    }
-                }
-            }
-            catch {
-                // Fallback if .gitmodules exists but can't be read or parsed
-            }
-        }
-        const files = await globby(["**/*"], {
-            cwd: this.projectPath,
-            gitignore: true,
-            ignore: [
-                ...submoduleIgnores,
-                "**/node_modules/**",
-                "**/dist/**",
-                "**/build/**",
-                "**/target/**", // Rust build artifacts
-                "**/bin/**",
-                "**/obj/**",
-                "**/.next/**",
-                "**/.svelte-kit/**",
-                "**/.nuxt/**",
-                "**/.cache/**",
-                "**/out/**",
-                "**/__tests__/**",
-                "**/coverage/**",
-                "**/*.test.*",
-                "**/*.spec.*",
-                "**/*.d.ts",
-                "**/tsconfig.tsbuildinfo",
-                "**/.locus/*.json", // Ignore index and other system JSONs
-                "**/.locus/*.md", // Ignore system MDs
-                "**/.locus/!(artifacts)/**", // Ignore everything in .locus EXCEPT artifacts
-                "**/.git/**",
-                "**/.svn/**",
-                "**/.hg/**",
-                "**/.vscode/**",
-                "**/.idea/**",
-                "**/.DS_Store",
-                "**/bun.lock",
-                "**/package-lock.json",
-                "**/yarn.lock",
-                "**/pnpm-lock.yaml",
-                "**/Cargo.lock",
-                "**/go.sum",
-                "**/poetry.lock",
-                // Binary/Large Assets
-                "**/*.{png,jpg,jpeg,gif,svg,ico,mp4,webm,wav,mp3,woff,woff2,eot,ttf,otf,pdf,zip,tar.gz,rar}",
-            ],
-        });
-        // Format the tree for the AI
-        const treeString = files.join("\n");
-        if (onProgress)
-            onProgress("AI is analyzing codebase structure...");
-        // 2. Ask AI to generate the index based on the tree
-        const index = await treeSummarizer(treeString);
-        // 3. Post-process: Ensure symbols are extracted for core files if not provided by AI
-        // (AI is good at structure, but might miss specific exports unless it reads the files)
-        // For now, we trust the AI's structural summary and can supplement symbols later if needed.
-        index.lastIndexed = new Date().toISOString();
-        return index;
-    }
-    loadIndex() {
-        if (existsSync(this.indexPath)) {
-            try {
-                return JSON.parse(readFileSync(this.indexPath, "utf-8"));
-            }
-            catch {
-                return null;
-            }
-        }
-        return null;
-    }
-    saveIndex(index) {
-        const dir = dirname(this.indexPath);
-        if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
-        }
-        writeFileSync(this.indexPath, JSON.stringify(index, null, 2));
-    }
-}

package/dist/core/prompt-builder.js

@@ -1,83 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { AssigneeRole } from "@locusai/shared";
-import { getLocusPath } from "./config.js";
-export class PromptBuilder {
-    projectPath;
-    constructor(projectPath) {
-        this.projectPath = projectPath;
-    }
-    async build(task) {
-        let prompt = `# Task: ${task.title}\n\n`;
-        const roleText = this.roleToText(task.assigneeRole);
-        if (roleText) {
-            prompt += `## Role\nYou are acting as a ${roleText}.\n\n`;
-        }
-        prompt += `## Description\n${task.description || "No description provided."}\n\n`;
-        // 1. Add CLAUDE.md context
-        const contextPath = getLocusPath(this.projectPath, "contextFile");
-        if (existsSync(contextPath)) {
-            try {
-                const context = readFileSync(contextPath, "utf-8");
-                prompt += `## Project Context (from CLAUDE.md)\n${context}\n\n`;
-            }
-            catch (err) {
-                console.warn(`Warning: Could not read context file: ${err}`);
-            }
-        }
-        // 2. Add Codebase Index context
-        const indexPath = getLocusPath(this.projectPath, "indexFile");
-        if (existsSync(indexPath)) {
-            prompt += `## Codebase Overview\nThere is an index file in the .locus/codebase-index.json and if you need you can check it.\n\n`;
-        }
-        // 3. Add Documents
-        if (task.docs && task.docs.length > 0) {
-            prompt += `## Attached Documents\n`;
-            for (const doc of task.docs) {
-                prompt += `### ${doc.title}\n${doc.content || "(No content)"}\n\n`;
-            }
-        }
-        // 4. Add Checklist
-        if (task.acceptanceChecklist && task.acceptanceChecklist.length > 0) {
-            prompt += `## Acceptance Criteria\n`;
-            for (const item of task.acceptanceChecklist) {
-                prompt += `- ${item.done ? "[x]" : "[ ]"} ${item.text}\n`;
-            }
-            prompt += "\n";
-        }
-        // 5. Add Comments & Feedback
-        if (task.comments && task.comments.length > 0) {
-            const comments = task.comments.slice(0, 5);
-            prompt += `## Task History & Feedback\n`;
-            prompt += `Review the following comments for context or rejection feedback:\n\n`;
-            for (const comment of comments) {
-                const date = new Date(comment.createdAt).toLocaleString();
-                prompt += `### ${comment.author} (${date})\n${comment.text}\n\n`;
-            }
-        }
-        prompt += `## Instructions
-1. Complete this task. 
-2. **Artifact Management**: If you create any high-level documentation (PRDs, technical drafts, architecture docs), you MUST save them in \`.locus/artifacts/\`. Do NOT create them in the root directory.
-3. **Paths**: Use relative paths from the project root at all times. Do NOT use absolute local paths (e.g., /Users/...).
-4. When finished successfully, output: <promise>COMPLETE</promise>\n`;
-        return prompt;
-    }
-    roleToText(role) {
-        if (!role) {
-            return null;
-        }
-        switch (role) {
-            case AssigneeRole.BACKEND:
-                return "Backend Engineer";
-            case AssigneeRole.FRONTEND:
-                return "Frontend Engineer";
-            case AssigneeRole.PM:
-                return "Product Manager";
-            case AssigneeRole.QA:
-                return "QA Engineer";
-            case AssigneeRole.DESIGN:
-                return "Product Designer";
-            default:
-                return "engineer";
-        }
-    }
-}

package/dist/events.js

@@ -1,15 +0,0 @@
-import { EventEmitter } from "events";
-export var LocusEvent;
-(function (LocusEvent) {
-    LocusEvent["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
-    LocusEvent["AUTH_ERROR"] = "AUTH_ERROR";
-    LocusEvent["REQUEST_ERROR"] = "REQUEST_ERROR";
-})(LocusEvent || (LocusEvent = {}));
-export class LocusEmitter extends EventEmitter {
-    on(event, listener) {
-        return super.on(event, listener);
-    }
-    emit(event, ...args) {
-        return super.emit(event, ...args);
-    }
-}

package/dist/modules/auth.js

@@ -1,23 +0,0 @@
-import { BaseModule } from "./base.js";
-export class AuthModule extends BaseModule {
-    async getMe() {
-        const { data } = await this.api.get("/auth/me");
-        return data;
-    }
-    async requestRegisterOtp(email) {
-        const { data } = await this.api.post("/auth/register-otp", { email });
-        return data;
-    }
-    async requestLoginOtp(email) {
-        const { data } = await this.api.post("/auth/login-otp", { email });
-        return data;
-    }
-    async verifyLogin(body) {
-        const { data } = await this.api.post("/auth/verify-login", body);
-        return data;
-    }
-    async completeRegistration(body) {
-        const { data } = await this.api.post("/auth/complete-registration", body);
-        return data;
-    }
-}