@locusai/sdk 0.4.6 → 0.4.10

package/dist/modules/base.js

@@ -1,8 +0,0 @@
-export class BaseModule {
-    api;
-    emitter;
-    constructor(api, emitter) {
-        this.api = api;
-        this.emitter = emitter;
-    }
-}

package/dist/modules/ci.js

@@ -1,7 +0,0 @@
-import { BaseModule } from "./base.js";
-export class CiModule extends BaseModule {
-    async report(body) {
-        const { data } = await this.api.post("/ci/report", body);
-        return data;
-    }
-}

package/dist/modules/docs.js

@@ -1,38 +0,0 @@
-import { BaseModule } from "./base.js";
-export class DocsModule extends BaseModule {
-    async create(workspaceId, body) {
-        const { data } = await this.api.post(`/workspaces/${workspaceId}/docs`, body);
-        return data.doc;
-    }
-    async list(workspaceId) {
-        const { data } = await this.api.get(`/workspaces/${workspaceId}/docs`);
-        return data.docs;
-    }
-    async getById(id, workspaceId) {
-        const { data } = await this.api.get(`/workspaces/${workspaceId}/docs/${id}`);
-        return data.doc;
-    }
-    async update(id, workspaceId, body) {
-        const { data } = await this.api.put(`/workspaces/${workspaceId}/docs/${id}`, body);
-        return data.doc;
-    }
-    async delete(id, workspaceId) {
-        await this.api.delete(`/workspaces/${workspaceId}/docs/${id}`);
-    }
-    // Group Management
-    async listGroups(workspaceId) {
-        const { data } = await this.api.get(`/workspaces/${workspaceId}/doc-groups`);
-        return data.groups;
-    }
-    async createGroup(workspaceId, body) {
-        const { data } = await this.api.post(`/workspaces/${workspaceId}/doc-groups`, body);
-        return data.group;
-    }
-    async updateGroup(id, workspaceId, body) {
-        const { data } = await this.api.patch(`/workspaces/${workspaceId}/doc-groups/${id}`, body);
-        return data.group;
-    }
-    async deleteGroup(id, workspaceId) {
-        await this.api.delete(`/workspaces/${workspaceId}/doc-groups/${id}`);
-    }
-}

package/dist/modules/invitations.js

@@ -1,22 +0,0 @@
-import { BaseModule } from "./base.js";
-export class InvitationsModule extends BaseModule {
-    async create(orgId, body) {
-        const { data } = await this.api.post(`/org/${orgId}/invitations`, body);
-        return data.invitation;
-    }
-    async list(orgId) {
-        const { data } = await this.api.get(`/org/${orgId}/invitations`);
-        return data.invitations;
-    }
-    async verify(token) {
-        const { data } = await this.api.get(`/invitations/verify/${token}`);
-        return data;
-    }
-    async accept(body) {
-        const { data } = await this.api.post("/invitations/accept", body);
-        return data;
-    }
-    async revoke(orgId, id) {
-        await this.api.delete(`/org/${orgId}/invitations/${id}`);
-    }
-}

package/dist/modules/organizations.js

@@ -1,39 +0,0 @@
-import { BaseModule } from "./base.js";
-export class OrganizationsModule extends BaseModule {
-    async list() {
-        const { data } = await this.api.get("/organizations");
-        return data.organizations;
-    }
-    async getById(id) {
-        const { data } = await this.api.get(`/organizations/${id}`);
-        return data.organization;
-    }
-    async listMembers(id) {
-        const { data } = await this.api.get(`/organizations/${id}/members`);
-        return data.members;
-    }
-    async addMember(id, body) {
-        const { data } = await this.api.post(`/organizations/${id}/members`, body);
-        return data.membership;
-    }
-    async removeMember(orgId, userId) {
-        await this.api.delete(`/organizations/${orgId}/members/${userId}`);
-    }
-    async delete(orgId) {
-        await this.api.delete(`/organizations/${orgId}`);
-    }
-    // ============================================================================
-    // API Key Management
-    // ============================================================================
-    async listApiKeys(orgId) {
-        const { data } = await this.api.get(`/organizations/${orgId}/api-keys`);
-        return data.apiKeys;
-    }
-    async createApiKey(orgId, name) {
-        const { data } = await this.api.post(`/organizations/${orgId}/api-keys`, { name });
-        return data.apiKey;
-    }
-    async deleteApiKey(orgId, keyId) {
-        await this.api.delete(`/organizations/${orgId}/api-keys/${keyId}`);
-    }
-}

package/dist/modules/sprints.js

@@ -1,34 +0,0 @@
-import { BaseModule } from "./base.js";
-export class SprintsModule extends BaseModule {
-    async list(workspaceId) {
-        const { data } = await this.api.get(`/workspaces/${workspaceId}/sprints`);
-        return data.sprints;
-    }
-    async getActive(workspaceId) {
-        const { data } = await this.api.get(`/workspaces/${workspaceId}/sprints/active`);
-        return data.sprint;
-    }
-    async getById(id, workspaceId) {
-        const { data } = await this.api.get(`/workspaces/${workspaceId}/sprints/${id}`);
-        return data.sprint;
-    }
-    async create(workspaceId, body) {
-        const { data } = await this.api.post(`/workspaces/${workspaceId}/sprints`, body);
-        return data.sprint;
-    }
-    async update(id, workspaceId, body) {
-        const { data } = await this.api.patch(`/workspaces/${workspaceId}/sprints/${id}`, body);
-        return data.sprint;
-    }
-    async delete(id, workspaceId) {
-        await this.api.delete(`/workspaces/${workspaceId}/sprints/${id}`);
-    }
-    async start(id, workspaceId) {
-        const { data } = await this.api.post(`/workspaces/${workspaceId}/sprints/${id}/start`);
-        return data.sprint;
-    }
-    async complete(id, workspaceId) {
-        const { data } = await this.api.post(`/workspaces/${workspaceId}/sprints/${id}/complete`);
-        return data.sprint;
-    }
-}

package/dist/modules/tasks.js

@@ -1,56 +0,0 @@
-import { TaskStatus, } from "@locusai/shared";
-import { BaseModule } from "./base.js";
-export class TasksModule extends BaseModule {
-    /**
-     * List all tasks in a workspace, optionally filtered
-     */
-    async list(workspaceId, options) {
-        const { data } = await this.api.get(`/workspaces/${workspaceId}/tasks`);
-        let tasks = data.tasks;
-        // Client-side filtering (API doesn't support query params yet)
-        if (options?.sprintId) {
-            tasks = tasks.filter((t) => t.sprintId === options.sprintId);
-        }
-        if (options?.status) {
-            const statuses = Array.isArray(options.status)
-                ? options.status
-                : [options.status];
-            tasks = tasks.filter((t) => statuses.includes(t.status));
-        }
-        return tasks;
-    }
-    /**
-     * Get available tasks for an agent to work on.
-     * Returns tasks in BACKLOG or IN_PROGRESS (unassigned) status.
-     */
-    async getAvailable(workspaceId, sprintId) {
-        const tasks = await this.list(workspaceId, {
-            sprintId,
-        });
-        return tasks.filter((t) => t.status === TaskStatus.BACKLOG ||
-            (t.status === TaskStatus.IN_PROGRESS && !t.assignedTo));
-    }
-    async getById(id, workspaceId) {
-        const { data } = await this.api.get(`/workspaces/${workspaceId}/tasks/${id}`);
-        return data.task;
-    }
-    async create(workspaceId, body) {
-        const { data } = await this.api.post(`/workspaces/${workspaceId}/tasks`, body);
-        return data.task;
-    }
-    async update(id, workspaceId, body) {
-        const { data } = await this.api.patch(`/workspaces/${workspaceId}/tasks/${id}`, body);
-        return data.task;
-    }
-    async delete(id, workspaceId) {
-        await this.api.delete(`/workspaces/${workspaceId}/tasks/${id}`);
-    }
-    async getBacklog(workspaceId) {
-        const { data } = await this.api.get(`/workspaces/${workspaceId}/tasks/backlog`);
-        return data.tasks;
-    }
-    async addComment(id, workspaceId, body) {
-        const { data } = await this.api.post(`/workspaces/${workspaceId}/tasks/${id}/comment`, body);
-        return data.comment;
-    }
-}

package/dist/modules/workspaces.js

@@ -1,49 +0,0 @@
-import { BaseModule } from "./base.js";
-export class WorkspacesModule extends BaseModule {
-    async listAll() {
-        const { data } = await this.api.get("/workspaces");
-        return data.workspaces;
-    }
-    async listByOrg(orgId) {
-        const { data } = await this.api.get(`/workspaces/org/${orgId}`);
-        return data.workspaces;
-    }
-    async create(body) {
-        const { orgId, ...bodyWithoutOrgId } = body;
-        const { data } = await this.api.post(`/workspaces/org/${orgId}`, bodyWithoutOrgId);
-        return data.workspace;
-    }
-    async createWithAutoOrg(body) {
-        const { data } = await this.api.post("/workspaces", body);
-        return data.workspace;
-    }
-    async getById(id) {
-        const { data } = await this.api.get(`/workspaces/${id}`);
-        return data.workspace;
-    }
-    async update(id, body) {
-        const { data } = await this.api.put(`/workspaces/${id}`, body);
-        return data.workspace;
-    }
-    async delete(id) {
-        await this.api.delete(`/workspaces/${id}`);
-    }
-    async getStats(id) {
-        const { data } = await this.api.get(`/workspaces/${id}/stats`);
-        return data;
-    }
-    async getActivity(id, limit) {
-        const { data } = await this.api.get(`/workspaces/${id}/activity`, {
-            params: { limit },
-        });
-        return data.activity;
-    }
-    /**
-     * Dispatch a task from the workspace backlog to an agent.
-     * Atomically moves a task from BACKLOG to IN_PROGRESS and assigns it.
-     */
-    async dispatch(id, workerId, sprintId) {
-        const { data } = await this.api.post(`/workspaces/${id}/dispatch`, { workerId, sprintId });
-        return data.task;
-    }
-}

package/dist/orchestrator.js

@@ -1,356 +0,0 @@
-import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { TaskPriority, TaskStatus } from "@locusai/shared";
-import { EventEmitter } from "events";
-import { LocusClient } from "./index.js";
-import { c } from "./utils/colors.js";
-export class AgentOrchestrator extends EventEmitter {
-    client;
-    config;
-    agents = new Map();
-    isRunning = false;
-    processedTasks = new Set();
-    resolvedSprintId = null;
-    constructor(config) {
-        super();
-        this.config = config;
-        this.client = new LocusClient({
-            baseUrl: config.apiBase,
-            token: config.apiKey,
-        });
-    }
-    /**
-     * Resolve the sprint ID - use provided or find active sprint
-     */
-    async resolveSprintId() {
-        if (this.config.sprintId) {
-            return this.config.sprintId;
-        }
-        // Try to find active sprint in workspace
-        try {
-            const sprint = await this.client.sprints.getActive(this.config.workspaceId);
-            if (sprint?.id) {
-                console.log(c.info(`📋 Using active sprint: ${sprint.name}`));
-                return sprint.id;
-            }
-        }
-        catch {
-            // No active sprint found, will work with all tasks
-        }
-        console.log(c.dim("ℹ  No sprint specified, working with all workspace tasks"));
-        return "";
-    }
-    /**
-     * Start the orchestrator with N agents
-     */
-    async start() {
-        if (this.isRunning) {
-            throw new Error("Orchestrator is already running");
-        }
-        this.isRunning = true;
-        this.processedTasks.clear();
-        try {
-            await this.orchestrationLoop();
-        }
-        catch (error) {
-            this.emit("error", error);
-            throw error;
-        }
-        finally {
-            await this.cleanup();
-        }
-    }
-    /**
-     * Main orchestration loop - runs 1 agent continuously
-     */
-    async orchestrationLoop() {
-        // Resolve sprint ID first
-        this.resolvedSprintId = await this.resolveSprintId();
-        this.emit("started", {
-            timestamp: new Date(),
-            config: this.config,
-            sprintId: this.resolvedSprintId,
-        });
-        console.log(`\n${c.primary("🤖 Locus Agent Orchestrator")}`);
-        console.log(c.dim("----------------------------------------------"));
-        console.log(`${c.bold("Workspace:")} ${this.config.workspaceId}`);
-        if (this.resolvedSprintId) {
-            console.log(`${c.bold("Sprint:")} ${this.resolvedSprintId}`);
-        }
-        console.log(`${c.bold("API Base:")} ${this.config.apiBase}`);
-        console.log(c.dim("----------------------------------------------\n"));
-        // Check if there are tasks to work on before spawning
-        const tasks = await this.getAvailableTasks();
-        if (tasks.length === 0) {
-            console.log(c.dim("ℹ  No available tasks found in the backlog."));
-            return;
-        }
-        // Spawn single agent
-        await this.spawnAgent();
-        // Wait for agent to complete
-        while (this.agents.size > 0 && this.isRunning) {
-            await this.reapAgents();
-            if (this.agents.size === 0) {
-                break;
-            }
-            await this.sleep(2000);
-        }
-        console.log(`\n${c.success("✅ Orchestrator finished")}`);
-    }
-    /**
-     * Find the package root by looking for package.json
-     */
-    findPackageRoot(startPath) {
-        let currentDir = startPath;
-        while (currentDir !== "/") {
-            if (existsSync(join(currentDir, "package.json"))) {
-                return currentDir;
-            }
-            currentDir = dirname(currentDir);
-        }
-        // Fallback to startPath if not found
-        return startPath;
-    }
-    /**
-     * Spawn a single agent process
-     */
-    async spawnAgent() {
-        const agentId = `agent-${Date.now()}-${Math.random()
-            .toString(36)
-            .slice(2, 9)}`;
-        const agentState = {
-            id: agentId,
-            status: "IDLE",
-            currentTaskId: null,
-            tasksCompleted: 0,
-            tasksFailed: 0,
-            lastHeartbeat: new Date(),
-        };
-        this.agents.set(agentId, agentState);
-        console.log(`${c.primary("🚀 Agent started:")} ${c.bold(agentId)}\n`);
-        // Build arguments for agent worker
-        // Try multiple resolution strategies
-        const potentialPaths = [];
-        // Strategy 1: Use import.meta.resolve to find the installed SDK package
-        try {
-            // Resolve the SDK's index to find the package location
-            const sdkIndexPath = import.meta.resolve("@locusai/sdk");
-            const sdkDir = dirname(sdkIndexPath.replace("file://", ""));
-            // In production, files are in dist/; sdkDir points to dist/ or src/
-            const sdkRoot = this.findPackageRoot(sdkDir);
-            potentialPaths.push(join(sdkRoot, "dist", "agent", "worker.js"), join(sdkRoot, "src", "agent", "worker.ts"));
-        }
-        catch {
-            // import.meta.resolve failed, continue with fallback strategies
-        }
-        // Strategy 2: Find package root from __dirname (works in dev/local)
-        const packageRoot = this.findPackageRoot(__dirname);
-        potentialPaths.push(join(packageRoot, "dist", "agent", "worker.js"), join(packageRoot, "src", "agent", "worker.ts"), join(__dirname, "agent", "worker.ts"), join(__dirname, "agent", "worker.js"));
-        const workerPath = potentialPaths.find((p) => existsSync(p));
-        // Verify worker file exists
-        if (!workerPath) {
-            throw new Error(`Worker file not found. Checked: ${potentialPaths.join(", ")}. ` +
-                `Make sure the SDK is properly built and installed.`);
-        }
-        const workerArgs = [
-            "--agent-id",
-            agentId,
-            "--workspace-id",
-            this.config.workspaceId,
-            "--api-base",
-            this.config.apiBase,
-            "--api-key",
-            this.config.apiKey,
-            "--project-path",
-            this.config.projectPath,
-        ];
-        // Add anthropic API key if provided
-        if (this.config.anthropicApiKey) {
-            workerArgs.push("--anthropic-api-key", this.config.anthropicApiKey);
-        }
-        // Add model if specified
-        if (this.config.model) {
-            workerArgs.push("--model", this.config.model);
-        }
-        // Add sprint ID if resolved
-        if (this.resolvedSprintId) {
-            workerArgs.push("--sprint-id", this.resolvedSprintId);
-        }
-        // Use node to run the worker script
-        const agentProcess = spawn(process.execPath, [workerPath, ...workerArgs]);
-        agentState.process = agentProcess;
-        agentProcess.on("message", (msg) => {
-            if (msg.type === "stats") {
-                agentState.tasksCompleted = msg.tasksCompleted || 0;
-                agentState.tasksFailed = msg.tasksFailed || 0;
-            }
-        });
-        agentProcess.stdout?.on("data", (data) => {
-            process.stdout.write(data.toString());
-        });
-        agentProcess.stderr?.on("data", (data) => {
-            process.stderr.write(`[${agentId}] ERR: ${data.toString()}`);
-        });
-        agentProcess.on("exit", (code) => {
-            console.log(`\n${agentId} finished (exit code: ${code})`);
-            const agent = this.agents.get(agentId);
-            if (agent) {
-                agent.status = code === 0 ? "COMPLETED" : "FAILED";
-                // Ensure CLI gets the absolute latest stats
-                this.emit("agent:completed", {
-                    agentId,
-                    status: agent.status,
-                    tasksCompleted: agent.tasksCompleted,
-                    tasksFailed: agent.tasksFailed,
-                });
-                // Remove from active tracking after emitting
-                this.agents.delete(agentId);
-            }
-        });
-        this.emit("agent:spawned", { agentId });
-    }
-    /**
-     * Reap completed agents
-     */
-    async reapAgents() {
-        // No-op: agents now remove themselves in the 'exit' listener
-        // to ensure events are emitted with correct stats before deletion.
-    }
-    /**
-     * Get available tasks in sprint
-     */
-    async getAvailableTasks() {
-        try {
-            const tasks = await this.client.tasks.getAvailable(this.config.workspaceId, this.resolvedSprintId || undefined);
-            return tasks.filter((task) => !this.processedTasks.has(task.id));
-        }
-        catch (error) {
-            this.emit("error", error);
-            return [];
-        }
-    }
-    /**
-     * Assign task to agent
-     */
-    async assignTaskToAgent(agentId) {
-        const agent = this.agents.get(agentId);
-        if (!agent)
-            return null;
-        try {
-            const tasks = await this.getAvailableTasks();
-            const priorityOrder = [
-                TaskPriority.CRITICAL,
-                TaskPriority.HIGH,
-                TaskPriority.MEDIUM,
-                TaskPriority.LOW,
-            ];
-            // Find task with highest priority
-            let task = tasks.sort((a, b) => priorityOrder.indexOf(a.priority) - priorityOrder.indexOf(b.priority))[0];
-            // Fallback: any available task
-            if (!task && tasks.length > 0) {
-                task = tasks[0];
-            }
-            if (!task)
-                return null;
-            agent.currentTaskId = task.id;
-            agent.status = "WORKING";
-            this.emit("task:assigned", {
-                agentId,
-                taskId: task.id,
-                title: task.title,
-            });
-            return task;
-        }
-        catch (error) {
-            this.emit("error", error);
-            return null;
-        }
-    }
-    /**
-     * Mark task as completed by agent
-     */
-    async completeTask(taskId, agentId, summary) {
-        try {
-            await this.client.tasks.update(taskId, this.config.workspaceId, {
-                status: TaskStatus.VERIFICATION,
-            });
-            if (summary) {
-                await this.client.tasks.addComment(taskId, this.config.workspaceId, {
-                    author: agentId,
-                    text: `✅ Task completed\n\n${summary}`,
-                });
-            }
-            this.processedTasks.add(taskId);
-            const agent = this.agents.get(agentId);
-            if (agent) {
-                agent.tasksCompleted += 1;
-                agent.currentTaskId = null;
-                agent.status = "IDLE";
-            }
-            this.emit("task:completed", { agentId, taskId });
-        }
-        catch (error) {
-            this.emit("error", error);
-        }
-    }
-    /**
-     * Mark task as failed
-     */
-    async failTask(taskId, agentId, error) {
-        try {
-            await this.client.tasks.update(taskId, this.config.workspaceId, {
-                status: TaskStatus.BACKLOG,
-                assignedTo: null,
-            });
-            await this.client.tasks.addComment(taskId, this.config.workspaceId, {
-                author: agentId,
-                text: `❌ Agent failed: ${error}`,
-            });
-            const agent = this.agents.get(agentId);
-            if (agent) {
-                agent.tasksFailed += 1;
-                agent.currentTaskId = null;
-                agent.status = "IDLE";
-            }
-            this.emit("task:failed", { agentId, taskId, error });
-        }
-        catch (error) {
-            this.emit("error", error);
-        }
-    }
-    /**
-     * Stop orchestrator
-     */
-    async stop() {
-        this.isRunning = false;
-        await this.cleanup();
-        this.emit("stopped", { timestamp: new Date() });
-    }
-    /**
-     * Cleanup - kill all agent processes
-     */
-    async cleanup() {
-        for (const [agentId, agent] of this.agents.entries()) {
-            if (agent.process && !agent.process.killed) {
-                console.log(`Killing agent: ${agentId}`);
-                agent.process.kill();
-            }
-        }
-        this.agents.clear();
-    }
-    /**
-     * Get orchestrator stats
-     */
-    getStats() {
-        return {
-            activeAgents: this.agents.size,
-            processedTasks: this.processedTasks.size,
-            totalTasksCompleted: Array.from(this.agents.values()).reduce((sum, agent) => sum + agent.tasksCompleted, 0),
-            totalTasksFailed: Array.from(this.agents.values()).reduce((sum, agent) => sum + agent.tasksFailed, 0),
-        };
-    }
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-}

package/dist/utils/colors.js

@@ -1,54 +0,0 @@
-/**
- * Simple ANSI color utility for terminal output
- * Dependency-free and works in Node.js/Bun environments
- */
-const ESC = "\u001b[";
-const RESET = `${ESC}0m`;
-const colors = {
-    reset: RESET,
-    bold: `${ESC}1m`,
-    dim: `${ESC}2m`,
-    italic: `${ESC}3m`,
-    underline: `${ESC}4m`,
-    // Foreground colors
-    black: `${ESC}30m`,
-    red: `${ESC}31m`,
-    green: `${ESC}32m`,
-    yellow: `${ESC}33m`,
-    blue: `${ESC}34m`,
-    magenta: `${ESC}35m`,
-    cyan: `${ESC}36m`,
-    white: `${ESC}37m`,
-    gray: `${ESC}90m`,
-    // Foreground bright colors
-    brightRed: `${ESC}91m`,
-    brightGreen: `${ESC}92m`,
-    brightYellow: `${ESC}93m`,
-    brightBlue: `${ESC}94m`,
-    brightMagenta: `${ESC}95m`,
-    brightCyan: `${ESC}96m`,
-    brightWhite: `${ESC}97m`,
-};
-export const c = {
-    text: (text, ...colorNames) => {
-        const codes = colorNames.map((name) => colors[name]).join("");
-        return `${codes}${text}${RESET}`;
-    },
-    // Shortcuts
-    bold: (t) => c.text(t, "bold"),
-    dim: (t) => c.text(t, "dim"),
-    red: (t) => c.text(t, "red"),
-    green: (t) => c.text(t, "green"),
-    yellow: (t) => c.text(t, "yellow"),
-    blue: (t) => c.text(t, "blue"),
-    magenta: (t) => c.text(t, "magenta"),
-    cyan: (t) => c.text(t, "cyan"),
-    gray: (t) => c.text(t, "gray"),
-    // Combinations
-    success: (t) => c.text(t, "green", "bold"),
-    error: (t) => c.text(t, "red", "bold"),
-    warning: (t) => c.text(t, "yellow", "bold"),
-    info: (t) => c.text(t, "cyan", "bold"),
-    primary: (t) => c.text(t, "blue", "bold"),
-    underline: (t) => c.text(t, "underline"),
-};