@locusai/server 0.1.0

package/src/repositories/comment.repository.ts

@@ -0,0 +1,32 @@
+import { BaseRepository } from "./base.repository.js";
+
+export interface DBComment {
+  id: number;
+  taskId: number;
+  author: string;
+  text: string;
+  createdAt: number;
+}
+
+export class CommentRepository extends BaseRepository {
+  findByTaskId(taskId: number | string): DBComment[] {
+    return this.db
+      .prepare(
+        "SELECT * FROM comments WHERE taskId = ? ORDER BY createdAt DESC"
+      )
+      .all(taskId) as DBComment[];
+  }
+
+  create(taskId: number | string, author: string, text: string): void {
+    const now = Date.now();
+    this.db
+      .prepare(
+        "INSERT INTO comments (taskId, author, text, createdAt) VALUES (?, ?, ?, ?)"
+      )
+      .run(taskId, author, text, now);
+  }
+
+  deleteByTaskId(taskId: number | string): void {
+    this.db.prepare("DELETE FROM comments WHERE taskId = ?").run(taskId);
+  }
+}

package/src/repositories/event.repository.ts

@@ -0,0 +1,34 @@
+import { BaseRepository } from "./base.repository.js";
+
+export interface DBEvent {
+  id: number;
+  taskId: number;
+  type: string;
+  payload: string;
+  createdAt: number;
+}
+
+export class EventRepository extends BaseRepository {
+  findByTaskId(taskId: number | string): DBEvent[] {
+    return this.db
+      .prepare("SELECT * FROM events WHERE taskId = ? ORDER BY createdAt DESC")
+      .all(taskId) as DBEvent[];
+  }
+
+  create(
+    taskId: number | string,
+    type: string,
+    payload: Record<string, unknown>
+  ): void {
+    const now = Date.now();
+    this.db
+      .prepare(
+        "INSERT INTO events (taskId, type, payload, createdAt) VALUES (?, ?, ?, ?)"
+      )
+      .run(String(taskId), type, JSON.stringify(payload), now);
+  }
+
+  deleteByTaskId(taskId: number | string): void {
+    this.db.prepare("DELETE FROM events WHERE taskId = ?").run(taskId);
+  }
+}

package/src/repositories/sprint.repository.ts

@@ -0,0 +1,60 @@
+import { BaseRepository } from "./base.repository.js";
+
+export interface DBSprint {
+  id: number;
+  name: string;
+  status: string;
+  startDate?: number;
+  endDate?: number;
+  createdAt: number;
+}
+
+export class SprintRepository extends BaseRepository {
+  findAll(): DBSprint[] {
+    return this.db
+      .prepare("SELECT * FROM sprints ORDER BY createdAt DESC")
+      .all() as DBSprint[];
+  }
+
+  findById(id: number | string): DBSprint | undefined {
+    return this.db.prepare("SELECT * FROM sprints WHERE id = ?").get(id) as
+      | DBSprint
+      | undefined;
+  }
+
+  findActive(): DBSprint | undefined {
+    return this.db
+      .prepare("SELECT * FROM sprints WHERE status = 'ACTIVE' LIMIT 1")
+      .get() as DBSprint | undefined;
+  }
+
+  create(name: string): number {
+    const now = Date.now();
+    const result = this.db
+      .prepare(
+        "INSERT INTO sprints (name, status, createdAt) VALUES (?, 'PLANNED', ?)"
+      )
+      .run(name, now);
+    return result.lastInsertRowid as number;
+  }
+
+  update(id: number | string, updates: Partial<DBSprint>): void {
+    const fields: string[] = [];
+    const vals: unknown[] = [];
+
+    for (const [key, val] of Object.entries(updates)) {
+      if (key === "id" || key === "createdAt") continue;
+      fields.push(`${key} = ?`);
+      vals.push(val);
+    }
+
+    if (fields.length === 0) return;
+
+    vals.push(id);
+
+    const stmt = this.db.prepare(
+      `UPDATE sprints SET ${fields.join(", ")} WHERE id = ?`
+    );
+    (stmt.run as (...args: unknown[]) => void)(...vals);
+  }
+}

package/src/repositories/task.repository.ts

@@ -0,0 +1,159 @@
+import type { SQLQueryBindings } from "bun:sqlite";
+import type { Task } from "@locusai/shared";
+import { CreateTaskData } from "../services/task.service.js";
+import { BaseRepository } from "./base.repository.js";
+
+export class TaskRepository extends BaseRepository {
+  findAll(): Task[] {
+    const tasks = this.db
+      .prepare("SELECT * FROM tasks ORDER BY createdAt DESC")
+      .all() as Task[];
+
+    return tasks.map((t) => this.format(t));
+  }
+
+  findById(id: number | string): Task | undefined {
+    const task = this.db.prepare("SELECT * FROM tasks WHERE id = ?").get(id) as
+      | Task
+      | undefined;
+
+    return task ? this.format(task) : undefined;
+  }
+
+  create(data: CreateTaskData): number {
+    const {
+      title,
+      description,
+      status,
+      priority,
+      labels,
+      assigneeRole,
+      parentId,
+      sprintId,
+      acceptanceChecklist,
+    } = data;
+    const now = Date.now();
+
+    const result = this.db
+      .prepare(`
+        INSERT INTO tasks (title, description, status, priority, labels, assigneeRole, parentId, sprintId, acceptanceChecklist, createdAt, updatedAt)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `)
+      .run(
+        title,
+        description,
+        status,
+        priority || "MEDIUM",
+        JSON.stringify(labels || []),
+        assigneeRole ?? null,
+        parentId ?? null,
+        sprintId ?? null,
+        JSON.stringify(acceptanceChecklist || []),
+        now,
+        now
+      );
+
+    return result.lastInsertRowid as number;
+  }
+
+  update(id: number | string, updates: Partial<Task>): void {
+    const fields: string[] = [];
+    const vals: unknown[] = [];
+
+    for (const [key, val] of Object.entries(updates)) {
+      if (key === "id" || key === "createdAt" || key === "updatedAt") continue;
+      fields.push(`${key} = ?`);
+      vals.push(typeof val === "object" ? JSON.stringify(val) : val);
+    }
+
+    if (fields.length === 0) return;
+
+    vals.push(Date.now(), id);
+
+    const stmt = this.db.prepare(
+      `UPDATE tasks SET ${fields.join(", ")}, updatedAt = ? WHERE id = ?`
+    );
+    (stmt.run as (...args: unknown[]) => void)(...vals);
+  }
+
+  delete(id: number | string): void {
+    this.db.prepare("DELETE FROM tasks WHERE id = ?").run(id);
+  }
+
+  findCandidateForDispatch(
+    now: number,
+    sprintId: number,
+    agentName: string,
+    expiresAt: number
+  ): Task | undefined {
+    return this.db.transaction(() => {
+      const query = `
+        SELECT * FROM tasks 
+        WHERE status = 'BACKLOG' 
+        AND (lockedBy IS NULL OR lockExpiresAt < ?)
+        AND sprintId = ?
+        ORDER BY 
+          CASE priority 
+            WHEN 'CRITICAL' THEN 1 
+            WHEN 'HIGH' THEN 2 
+            WHEN 'MEDIUM' THEN 3 
+            WHEN 'LOW' THEN 4 
+            ELSE 5 
+          END ASC,
+          createdAt ASC
+        LIMIT 1
+      `;
+      const params: SQLQueryBindings[] = [now, sprintId];
+
+      const candidate = this.db.prepare(query).get(...params) as
+        | Task
+        | undefined;
+
+      if (!candidate) return undefined;
+
+      // Lock it
+      this.db
+        .prepare(
+          "UPDATE tasks SET lockedBy = ?, lockExpiresAt = ?, updatedAt = ? WHERE id = ?"
+        )
+        .run(agentName, expiresAt, now, candidate.id);
+
+      return this.format(candidate);
+    })();
+  }
+
+  lock(
+    id: number | string,
+    agentId: string,
+    expiresAt: number,
+    now: number
+  ): void {
+    this.db
+      .prepare(
+        "UPDATE tasks SET lockedBy = ?, lockExpiresAt = ?, updatedAt = ? WHERE id = ?"
+      )
+      .run(agentId, expiresAt, now, id);
+  }
+
+  unlock(id: number | string, now: number): void {
+    this.db
+      .prepare(
+        "UPDATE tasks SET lockedBy = NULL, lockExpiresAt = NULL, updatedAt = ? WHERE id = ?"
+      )
+      .run(now, id);
+  }
+
+  private format(task: Task): Task {
+    return {
+      ...task,
+      labels:
+        typeof task.labels === "string"
+          ? JSON.parse(task.labels || "[]")
+          : task.labels || [],
+      acceptanceChecklist:
+        typeof task.acceptanceChecklist === "string"
+          ? JSON.parse(task.acceptanceChecklist || "[]")
+          : task.acceptanceChecklist || [],
+    };
+  }
+}

package/src/routes/artifacts.routes.ts

@@ -0,0 +1,11 @@
+import { Router } from "express";
+import type { ArtifactController } from "../controllers/artifact.controller.js";
+
+export function createArtifactsRouter(controller: ArtifactController) {
+  const router = Router();
+
+  router.get("/artifacts/:taskId", controller.getByTaskId);
+  router.get("/artifacts/:taskId/:type/:filename", controller.getArtifactFile);
+
+  return router;
+}

package/src/routes/ci.routes.ts

@@ -0,0 +1,10 @@
+import { Router } from "express";
+import type { CiController } from "../controllers/ci.controller.js";
+
+export function createCiRouter(controller: CiController) {
+  const router = Router();
+
+  router.post("/run", controller.run);
+
+  return router;
+}

package/src/routes/docs.routes.ts

@@ -0,0 +1,13 @@
+import { Router } from "express";
+import type { DocController } from "../controllers/doc.controller.js";
+
+export function createDocsRouter(controller: DocController) {
+  const router = Router();
+
+  router.get("/", controller.getAll);
+  router.get("/tree", controller.getTree);
+  router.get("/read", controller.read);
+  router.post("/write", controller.write);
+
+  return router;
+}

package/src/routes/events.routes.ts

@@ -0,0 +1,10 @@
+import { Router } from "express";
+import type { EventController } from "../controllers/event.controller.js";
+
+export function createEventsRouter(controller: EventController) {
+  const router = Router();
+
+  router.get("/", controller.getByTaskId);
+
+  return router;
+}

package/src/routes/sprints.routes.ts

@@ -0,0 +1,12 @@
+import { Router } from "express";
+import type { SprintController } from "../controllers/sprint.controller.js";
+
+export function createSprintsRouter(controller: SprintController) {
+  const router = Router();
+
+  router.get("/", controller.getAll);
+  router.post("/", controller.create);
+  router.patch("/:id", controller.updateStatus);
+
+  return router;
+}

package/src/routes/tasks.routes.ts

@@ -0,0 +1,18 @@
+import { Router } from "express";
+import type { TaskController } from "../controllers/task.controller.js";
+
+export function createTaskRouter(controller: TaskController) {
+  const router = Router();
+
+  router.get("/", controller.getAll);
+  router.get("/:id", controller.getById);
+  router.post("/", controller.create);
+  router.patch("/:id", controller.update);
+  router.delete("/:id", controller.delete);
+  router.post("/:id/comment", controller.addComment);
+  router.post("/dispatch", controller.dispatch);
+  router.post("/:id/lock", controller.lock);
+  router.post("/:id/unlock", controller.unlock);
+
+  return router;
+}

package/src/services/ci.service.ts

@@ -0,0 +1,65 @@
+import { readFileSync } from "node:fs";
+import type { ArtifactRepository } from "../repositories/artifact.repository.js";
+import type { EventRepository } from "../repositories/event.repository.js";
+import { ServiceError } from "./task.service.js";
+
+export class CiService {
+  constructor(
+    private artifactRepo: ArtifactRepository,
+    private eventRepo: EventRepository,
+    private config: { ciPresetsPath: string; repoPath: string }
+  ) {}
+
+  async runCi(taskId: number | string, preset: string) {
+    const presets = JSON.parse(
+      readFileSync(this.config.ciPresetsPath, "utf-8")
+    );
+    const commands = presets[preset];
+    if (!commands) throw new ServiceError(`Preset ${preset} not found`);
+
+    const results = [];
+    let allOk = true;
+    let combinedOutput = "";
+
+    for (const cmd of commands) {
+      const start = Date.now();
+      try {
+        if (/[;&|><$`\n]/.test(cmd)) throw new Error("Invalid command");
+
+        const proc = Bun.spawn(cmd.split(" "), {
+          cwd: this.config.repoPath,
+          stdout: "pipe",
+          stderr: "pipe",
+        });
+
+        const stdout = await new Response(proc.stdout).text();
+        const stderr = await new Response(proc.stderr).text();
+        const exitCode = await proc.exited;
+
+        const duration = Date.now() - start;
+        results.push({ cmd, exitCode, durationMs: duration });
+        combinedOutput += `\n> ${cmd}\n${stdout}${stderr}\n`;
+        if (exitCode !== 0) allOk = false;
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        results.push({ cmd, exitCode: -1, error: message });
+        allOk = false;
+        combinedOutput += `\n> ${cmd}\nError: ${message}\n`;
+      }
+    }
+
+    const summary = allOk ? "All checks passed" : "Some checks failed";
+
+    this.artifactRepo.create({
+      taskId: Number(taskId),
+      type: "CI_OUTPUT",
+      title: `CI Run: ${preset}`,
+      contentText: combinedOutput,
+      createdBy: "system",
+    });
+
+    this.eventRepo.create(taskId, "CI_RAN", { preset, ok: allOk, summary });
+
+    return { ok: allOk, preset, commands: results, summary };
+  }
+}

package/src/services/sprint.service.ts

@@ -0,0 +1,28 @@
+import type {
+  DBSprint,
+  SprintRepository,
+} from "../repositories/sprint.repository.js";
+
+export class SprintService {
+  constructor(private sprintRepo: SprintRepository) {}
+
+  getAllSprints() {
+    return this.sprintRepo.findAll();
+  }
+
+  getSprintById(id: number | string) {
+    return this.sprintRepo.findById(id);
+  }
+
+  createSprint(name: string) {
+    return this.sprintRepo.create(name);
+  }
+
+  updateSprint(id: number | string, updates: Partial<DBSprint>) {
+    this.sprintRepo.update(id, updates);
+  }
+
+  getActiveSprint() {
+    return this.sprintRepo.findActive();
+  }
+}

package/src/services/task.service.ts

@@ -0,0 +1,182 @@
+import type {
+  AcceptanceItem,
+  AssigneeRole,
+  EventType,
+  Task,
+  TaskPriority,
+  TaskStatus,
+} from "@locusai/shared";
+import type { ArtifactRepository } from "../repositories/artifact.repository.js";
+import type { CommentRepository } from "../repositories/comment.repository.js";
+import type { EventRepository } from "../repositories/event.repository.js";
+import type { TaskRepository } from "../repositories/task.repository.js";
+import type { TaskProcessor } from "../task-processor.js";
+
+export class ServiceError extends Error {
+  constructor(
+    public message: string,
+    public statusCode: number = 400
+  ) {
+    super(message);
+    this.name = "ServiceError";
+  }
+}
+
+export interface CreateTaskData {
+  title: string;
+  description: string;
+  status: TaskStatus;
+  priority: TaskPriority;
+  labels: string[];
+  assigneeRole?: AssigneeRole;
+  parentId?: number | null;
+  sprintId?: number | null;
+  acceptanceChecklist?: AcceptanceItem[];
+}
+
+export class TaskService {
+  constructor(
+    private taskRepo: TaskRepository,
+    private eventRepo: EventRepository,
+    private commentRepo: CommentRepository,
+    private artifactRepo: ArtifactRepository,
+    private processor: TaskProcessor
+  ) {}
+
+  getAllTasks(): Task[] {
+    return this.taskRepo.findAll();
+  }
+
+  getTaskById(id: number | string): Task {
+    const task = this.taskRepo.findById(id);
+    if (!task) throw new ServiceError("Task not found", 404);
+
+    const events = this.eventRepo.findByTaskId(id);
+    const comments = this.commentRepo.findByTaskId(id);
+    const artifacts = this.artifactRepo.findByTaskId(id);
+
+    return {
+      ...task,
+      activityLog: events.map((e) => ({
+        id: e.id,
+        taskId: Number(e.taskId),
+        type: e.type as EventType,
+        payload: JSON.parse(e.payload || "{}"),
+        createdAt: e.createdAt,
+      })),
+      comments: comments.map((c) => ({
+        id: c.id,
+        taskId: Number(c.taskId),
+        author: c.author,
+        text: c.text,
+        createdAt: c.createdAt,
+      })),
+      artifacts: artifacts.map((a) => ({
+        id: a.id,
+        taskId: Number(a.taskId),
+        type: a.type,
+        title: a.title,
+        url: a.filePath || "",
+        size: "0",
+        createdBy: a.createdBy || "system",
+        createdAt: a.createdAt,
+      })),
+    };
+  }
+
+  createTask(data: CreateTaskData): number {
+    const id = this.taskRepo.create(data);
+    this.eventRepo.create(id, "TASK_CREATED", { title: data.title });
+    return id;
+  }
+
+  updateTask(id: number | string, updates: Partial<Task>): void {
+    const oldTask = this.taskRepo.findById(id);
+    if (!oldTask) throw new ServiceError("Task not found", 404);
+
+    if (updates.status === "DONE" && oldTask.status !== "VERIFICATION") {
+      throw new ServiceError(
+        "Cannot move directly to DONE. Tasks must be in VERIFICATION first for human review."
+      );
+    }
+
+    this.taskRepo.update(id, updates);
+
+    if (updates.status && updates.status !== oldTask.status) {
+      this.eventRepo.create(id, "STATUS_CHANGED", {
+        oldStatus: oldTask.status,
+        newStatus: updates.status,
+      });
+
+      this.processor.onStatusChanged(
+        id.toString(),
+        oldTask.status,
+        updates.status
+      );
+    }
+  }
+
+  deleteTask(id: number | string): void {
+    const task = this.taskRepo.findById(id);
+    if (!task) throw new ServiceError("Task not found", 404);
+
+    this.commentRepo.deleteByTaskId(id);
+    this.eventRepo.deleteByTaskId(id);
+    this.artifactRepo.deleteByTaskId(id);
+    this.taskRepo.delete(id);
+  }
+
+  addComment(taskId: number | string, author: string, text: string): void {
+    this.commentRepo.create(taskId, author, text);
+    this.eventRepo.create(taskId, "COMMENT_ADDED", { author, text });
+  }
+
+  dispatchTask(workerId: string, sprintId: number): Task {
+    const now = Date.now();
+    const expiresAt = now + 3600 * 1000;
+    const agentName = workerId || `agent-${crypto.randomUUID().slice(0, 8)}`;
+
+    const task = this.taskRepo.findCandidateForDispatch(
+      now,
+      sprintId,
+      agentName,
+      expiresAt
+    );
+    if (!task) throw new ServiceError("No tasks available", 404);
+
+    this.eventRepo.create(task.id, "LOCKED", { agentId: agentName, expiresAt });
+    return task;
+  }
+
+  lockTask(id: number | string, agentId: string, ttlSeconds: number): void {
+    const task = this.taskRepo.findById(id);
+    if (!task) throw new ServiceError("Task not found", 404);
+
+    const now = Date.now();
+    const expiresAt = now + ttlSeconds * 1000;
+
+    if (
+      task.lockedBy &&
+      task.lockedBy !== agentId &&
+      (task.lockExpiresAt || 0) > now
+    ) {
+      throw new ServiceError(`Task locked by ${task.lockedBy}`, 403);
+    }
+
+    this.taskRepo.lock(id, agentId, expiresAt, now);
+    this.eventRepo.create(id, "LOCKED", { agentId, expiresAt });
+  }
+
+  unlockTask(id: number | string, agentId: string): void {
+    const task = this.taskRepo.findById(id);
+    if (!task) throw new ServiceError("Task not found", 404);
+
+    if (task.lockedBy && task.lockedBy !== agentId && agentId !== "human") {
+      throw new ServiceError("Not authorized to unlock", 403);
+    }
+
+    const now = Date.now();
+    this.taskRepo.unlock(id, now);
+    this.eventRepo.create(id, "UNLOCKED", { agentId });
+  }
+}