@axiom-lattice/gateway 3.0.2 → 3.0.3

package/src/controllers/schedules.ts

@@ -1,336 +0,0 @@
-import { FastifyRequest, FastifyReply } from "fastify";
-import { scheduleLatticeManager } from "@axiom-lattice/core";
-import {
-  ScheduledTaskDefinition,
-  ScheduledTaskStatus,
-} from "@axiom-lattice/protocols";
-
-/**
- * Schedule Controller
- * Handles schedule-related operations for viewing and managing scheduled tasks
- * All operations are scoped to a tenant ID
- */
-
-/**
- * Get tenant ID from request headers or user context
- */
-function getTenantId(request: FastifyRequest): string {
-  // First try to get from authenticated user context
-  const userTenantId = (request as any).user?.tenantId;
-  if (userTenantId) {
-    return userTenantId;
-  }
-
-  // Fallback to request headers for backward compatibility
-  return (request.headers["x-tenant-id"] as string) || "default";
-}
-
-/**
- * Scheduled tasks list response interface
- */
-interface ScheduledTasksListResponse {
-  success: boolean;
-  message: string;
-  data: {
-    records: ScheduledTaskDefinition[];
-    total: number;
-  };
-}
-
-/**
- * Scheduled task response interface
- */
-interface ScheduledTaskResponse {
-  success: boolean;
-  message: string;
-  data?: ScheduledTaskDefinition | null;
-}
-
-/**
- * Helper function to get the schedule lattice safely
- * Returns null if no schedule lattice is registered
- */
-function getScheduleLattice() {
-  // Try to get the first available schedule lattice
-  const keys = scheduleLatticeManager.getLatticeKeys();
-  if (keys.length === 0) {
-    return null;
-  }
-  // Use "default" if available, otherwise use the first one
-  if (scheduleLatticeManager.hasLattice("default")) {
-    return scheduleLatticeManager.getScheduleLattice("default");
-  }
-  return scheduleLatticeManager.getScheduleLattice(keys[0]);
-}
-
-/**
- * Get scheduled tasks for a specific thread
- */
-export async function getThreadSchedules(
-  request: FastifyRequest<{
-    Params: { assistantId: string; threadId: string };
-    Querystring: {
-      status?: ScheduledTaskStatus;
-      limit?: string;
-      offset?: string;
-    };
-  }>,
-  reply: FastifyReply
-): Promise<ScheduledTasksListResponse> {
-  const { assistantId, threadId } = request.params;
-  const { status, limit, offset } = request.query;
-
-  try {
-    const scheduleLattice = getScheduleLattice();
-
-    // If no schedule lattice is registered, return empty result
-    if (!scheduleLattice) {
-      return {
-        success: true,
-        message: "No schedule lattice configured",
-        data: {
-          records: [],
-          total: 0,
-        },
-      };
-    }
-
-    const storage = scheduleLattice.client.getStorage();
-
-    if (!storage) {
-      return {
-        success: true,
-        message: "No schedule storage configured",
-        data: {
-          records: [],
-          total: 0,
-        },
-      };
-    }
-
-    const tenantId = getTenantId(request);
-
-    const filters: {
-      tenantId: string;
-      threadId: string;
-      assistantId?: string;
-      status?: ScheduledTaskStatus;
-      limit?: number;
-      offset?: number;
-    } = {
-      tenantId,
-      threadId,
-      assistantId,
-    };
-
-    if (status) {
-      filters.status = status;
-    }
-    if (limit) {
-      filters.limit = parseInt(limit, 10);
-    }
-    if (offset) {
-      filters.offset = parseInt(offset, 10);
-    }
-
-    const tasks = await storage.getAllTasks(filters);
-    const total = await storage.countTasks({
-      tenantId,
-      threadId,
-      assistantId,
-      status,
-    });
-
-    return {
-      success: true,
-      message: "Successfully retrieved scheduled tasks",
-      data: {
-        records: tasks,
-        total,
-      },
-    };
-  } catch (error) {
-    request.log.error(error, "Failed to get thread schedules");
-    return reply.status(500).send({
-      success: false,
-      message: "Failed to retrieve scheduled tasks",
-      data: {
-        records: [],
-        total: 0,
-      },
-    });
-  }
-}
-
-/**
- * Get a single scheduled task by ID
- */
-export async function getScheduledTask(
-  request: FastifyRequest<{
-    Params: { taskId: string };
-  }>,
-  reply: FastifyReply
-): Promise<ScheduledTaskResponse> {
-  const { taskId } = request.params;
-
-  try {
-    const scheduleLattice = getScheduleLattice();
-
-    if (!scheduleLattice) {
-      return reply.status(404).send({
-        success: false,
-        message: "No schedule lattice configured",
-      });
-    }
-
-    const task = await scheduleLattice.client.getTask(taskId);
-
-    if (!task) {
-      return reply.status(404).send({
-        success: false,
-        message: "Scheduled task not found",
-      });
-    }
-
-    return {
-      success: true,
-      message: "Successfully retrieved scheduled task",
-      data: task,
-    };
-  } catch (error) {
-    request.log.error(error, "Failed to get scheduled task");
-    return reply.status(500).send({
-      success: false,
-      message: "Failed to retrieve scheduled task",
-    });
-  }
-}
-
-/**
- * Cancel a scheduled task
- */
-export async function cancelScheduledTask(
-  request: FastifyRequest<{
-    Params: { taskId: string };
-  }>,
-  reply: FastifyReply
-): Promise<{ success: boolean; message: string }> {
-  const { taskId } = request.params;
-
-  try {
-    const scheduleLattice = getScheduleLattice();
-
-    if (!scheduleLattice) {
-      return reply.status(404).send({
-        success: false,
-        message: "No schedule lattice configured",
-      });
-    }
-
-    const result = await scheduleLattice.client.cancel(taskId);
-
-    if (!result) {
-      return reply.status(404).send({
-        success: false,
-        message: "Scheduled task not found or already cancelled",
-      });
-    }
-
-    return {
-      success: true,
-      message: "Successfully cancelled scheduled task",
-    };
-  } catch (error) {
-    request.log.error(error, "Failed to cancel scheduled task");
-    return reply.status(500).send({
-      success: false,
-      message: "Failed to cancel scheduled task",
-    });
-  }
-}
-
-/**
- * Pause a scheduled cron task
- */
-export async function pauseScheduledTask(
-  request: FastifyRequest<{
-    Params: { taskId: string };
-  }>,
-  reply: FastifyReply
-): Promise<{ success: boolean; message: string }> {
-  const { taskId } = request.params;
-
-  try {
-    const scheduleLattice = getScheduleLattice();
-
-    if (!scheduleLattice) {
-      return reply.status(404).send({
-        success: false,
-        message: "No schedule lattice configured",
-      });
-    }
-
-    const result = await scheduleLattice.client.pause(taskId);
-
-    if (!result) {
-      return reply.status(404).send({
-        success: false,
-        message: "Scheduled task not found or cannot be paused",
-      });
-    }
-
-    return {
-      success: true,
-      message: "Successfully paused scheduled task",
-    };
-  } catch (error) {
-    request.log.error(error, "Failed to pause scheduled task");
-    return reply.status(500).send({
-      success: false,
-      message: "Failed to pause scheduled task",
-    });
-  }
-}
-
-/**
- * Resume a paused cron task
- */
-export async function resumeScheduledTask(
-  request: FastifyRequest<{
-    Params: { taskId: string };
-  }>,
-  reply: FastifyReply
-): Promise<{ success: boolean; message: string }> {
-  const { taskId } = request.params;
-
-  try {
-    const scheduleLattice = getScheduleLattice();
-
-    if (!scheduleLattice) {
-      return reply.status(404).send({
-        success: false,
-        message: "No schedule lattice configured",
-      });
-    }
-
-    const result = await scheduleLattice.client.resume(taskId);
-
-    if (!result) {
-      return reply.status(404).send({
-        success: false,
-        message: "Scheduled task not found or cannot be resumed",
-      });
-    }
-
-    return {
-      success: true,
-      message: "Successfully resumed scheduled task",
-    };
-  } catch (error) {
-    request.log.error(error, "Failed to resume scheduled task");
-    return reply.status(500).send({
-      success: false,
-      message: "Failed to resume scheduled task",
-    });
-  }
-}

package/src/controllers/skills.ts

@@ -1,256 +0,0 @@
-import { FastifyRequest, FastifyReply } from "fastify";
-import { SkillService } from "../services/skill_service";
-import type { Skill, CreateSkillRequest } from "@axiom-lattice/protocols";
-
-const skillService = new SkillService();
-
-function serializeSkill(skill: Skill): any {
-  const serialized: any = {
-    id: skill.id,
-    name: skill.name,
-    description: skill.description,
-    license: skill.license,
-    compatibility: skill.compatibility,
-    metadata: skill.metadata || {},
-    content: skill.content,
-    subSkills: skill.subSkills,
-    createdAt: skill.createdAt instanceof Date ? skill.createdAt.toISOString() : new Date().toISOString(),
-    updatedAt: skill.updatedAt instanceof Date ? skill.updatedAt.toISOString() : new Date().toISOString(),
-  };
-  Object.keys(serialized).forEach((key) => {
-    if (serialized[key] === undefined) delete serialized[key];
-  });
-  return serialized;
-}
-
-interface SkillListResponse {
-  success: boolean;
-  message: string;
-  data: { records: any[]; total: number };
-}
-
-interface SkillResponse {
-  success: boolean;
-  message: string;
-  data?: any;
-}
-
-interface SkillUpdateBody {
-  name?: string;
-  description?: string;
-  license?: string;
-  compatibility?: string;
-  metadata?: Record<string, string>;
-  content?: string;
-  subSkills?: string[];
-}
-
-export async function getSkillList(request: FastifyRequest, reply: FastifyReply): Promise<SkillListResponse> {
-  try {
-    const skills = await skillService.getAllSkills(request);
-    return {
-      success: true,
-      message: "Successfully retrieved skill list",
-      data: { records: skills.map(serializeSkill), total: skills.length },
-    };
-  } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to retrieve skills: ${error.message}`,
-      data: { records: [], total: 0 },
-    });
-  }
-}
-
-export async function getSkill(
-  request: FastifyRequest<{ Params: { id: string } }>,
-  reply: FastifyReply
-): Promise<SkillResponse> {
-  try {
-    const { id } = request.params;
-    const skill = await skillService.getSkillById(request, id);
-
-    if (!skill) {
-      return reply.status(404).send({ success: false, message: "Skill not found" });
-    }
-
-    return { success: true, message: "Successfully retrieved skill", data: serializeSkill(skill) };
-  } catch (error: any) {
-    return reply.status(500).send({ success: false, message: `Failed to retrieve skill: ${error.message}` });
-  }
-}
-
-export async function createSkill(
-  request: FastifyRequest<{ Body: CreateSkillRequest }>,
-  reply: FastifyReply
-): Promise<SkillResponse> {
-  try {
-    const data = request.body;
-    if (!data.name) {
-      return reply.status(400).send({ success: false, message: "name is required" });
-    }
-    if (!data.description) {
-      return reply.status(400).send({ success: false, message: "description is required" });
-    }
-
-    const id = (request.body as any).id || data.name;
-    if (id !== data.name) {
-      return reply.status(400).send({
-        success: false,
-        message: `id "${id}" must equal name "${data.name}"`,
-      });
-    }
-
-    const skill = await skillService.createSkill(request, id, data);
-    return reply.status(201).send({
-      success: true,
-      message: "Successfully created skill",
-      data: serializeSkill(skill),
-    });
-  } catch (error: any) {
-    if (error.message?.includes("already exists")) {
-      return reply.status(409).send({ success: false, message: error.message });
-    }
-    if (error.message?.includes("built-in skill")) {
-      return reply.status(403).send({ success: false, message: error.message });
-    }
-    if (error.message?.includes("must equal name") || error.message?.includes("Invalid skill name")) {
-      return reply.status(400).send({ success: false, message: error.message });
-    }
-    return reply.status(500).send({ success: false, message: `Failed to create skill: ${error.message}` });
-  }
-}
-
-export async function updateSkill(
-  request: FastifyRequest<{ Params: { id: string }; Body: SkillUpdateBody }>,
-  reply: FastifyReply
-): Promise<SkillResponse> {
-  try {
-    const { id } = request.params;
-    const updates = request.body;
-
-    const skill = await skillService.updateSkill(request, id, updates);
-
-    if (!skill) {
-      return reply.status(404).send({ success: false, message: "Skill not found" });
-    }
-
-    return { success: true, message: "Successfully updated skill", data: serializeSkill(skill) };
-  } catch (error: any) {
-    if (error.message?.includes("built-in skill")) {
-      return reply.status(403).send({ success: false, message: error.message });
-    }
-    if (error.message?.includes("Invalid skill name")) {
-      return reply.status(400).send({ success: false, message: error.message });
-    }
-    return reply.status(500).send({ success: false, message: `Failed to update skill: ${error.message}` });
-  }
-}
-
-export async function deleteSkill(
-  request: FastifyRequest<{ Params: { id: string } }>,
-  reply: FastifyReply
-): Promise<{ success: boolean; message: string }> {
-  try {
-    const { id } = request.params;
-    const result = await skillService.deleteSkill(request, id);
-
-    if (!result) {
-      return reply.status(404).send({ success: false, message: "Skill not found" });
-    }
-
-    return { success: true, message: "Successfully deleted skill" };
-  } catch (error: any) {
-    if (error.message?.includes("built-in skill")) {
-      return reply.status(403).send({ success: false, message: error.message });
-    }
-    return reply.status(500).send({ success: false, message: `Failed to delete skill: ${error.message}` });
-  }
-}
-
-export async function searchSkillsByMetadata(
-  request: FastifyRequest<{ Querystring: { key: string; value: string } }>,
-  reply: FastifyReply
-): Promise<SkillListResponse> {
-  try {
-    const { key, value } = request.query;
-    if (!key || !value) {
-      return reply.status(400).send({
-        success: false,
-        message: "key and value query parameters are required",
-        data: { records: [], total: 0 },
-      });
-    }
-
-    const skills = await skillService.searchByMetadata(request, key, value);
-    return {
-      success: true,
-      message: "Successfully searched skills",
-      data: { records: skills.map(serializeSkill), total: skills.length },
-    };
-  } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to search skills: ${error.message}`,
-      data: { records: [], total: 0 },
-    });
-  }
-}
-
-export async function filterSkillsByCompatibility(
-  request: FastifyRequest<{ Querystring: { compatibility: string } }>,
-  reply: FastifyReply
-): Promise<SkillListResponse> {
-  try {
-    const { compatibility } = request.query;
-    if (!compatibility) {
-      return reply.status(400).send({
-        success: false,
-        message: "compatibility query parameter is required",
-        data: { records: [], total: 0 },
-      });
-    }
-
-    const skills = await skillService.filterByCompatibility(request, compatibility);
-    return {
-      success: true,
-      message: "Successfully filtered skills",
-      data: { records: skills.map(serializeSkill), total: skills.length },
-    };
-  } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to filter skills: ${error.message}`,
-      data: { records: [], total: 0 },
-    });
-  }
-}
-
-export async function filterSkillsByLicense(
-  request: FastifyRequest<{ Querystring: { license: string } }>,
-  reply: FastifyReply
-): Promise<SkillListResponse> {
-  try {
-    const { license } = request.query;
-    if (!license) {
-      return reply.status(400).send({
-        success: false,
-        message: "license query parameter is required",
-        data: { records: [], total: 0 },
-      });
-    }
-
-    const skills = await skillService.filterByLicense(request, license);
-    return {
-      success: true,
-      message: "Successfully filtered skills",
-      data: { records: skills.map(serializeSkill), total: skills.length },
-    };
-  } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to filter skills: ${error.message}`,
-      data: { records: [], total: 0 },
-    });
-  }
-}