@axiom-lattice/gateway 2.1.20 → 2.1.21

package/dist/index.mjs

@@ -1319,6 +1319,311 @@ async function getHealth(request, reply) {
   }
 }
 
+// src/controllers/skills.ts
+import { getStoreLattice as getStoreLattice3 } from "@axiom-lattice/core";
+import { validateSkillName } from "@axiom-lattice/core";
+function serializeSkill(skill) {
+  const serialized = {
+    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() : skill.createdAt ? new Date(skill.createdAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: skill.updatedAt instanceof Date ? skill.updatedAt.toISOString() : skill.updatedAt ? new Date(skill.updatedAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString()
+  };
+  Object.keys(serialized).forEach((key) => {
+    if (serialized[key] === void 0) {
+      delete serialized[key];
+    }
+  });
+  return serialized;
+}
+async function getSkillList(request, reply) {
+  try {
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.getAllSkills();
+    const serializedSkills = skills.map(serializeSkill);
+    return {
+      success: true,
+      message: "Successfully retrieved skill list",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length
+      }
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0
+      }
+    });
+  }
+}
+async function getSkill(request, reply) {
+  try {
+    const { id } = request.params;
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const skill = await skillStore.getSkillById(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) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve skill: ${error.message}`
+    });
+  }
+}
+async function createSkill(request, reply) {
+  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"
+      });
+    }
+    try {
+      validateSkillName(data.name);
+    } catch (error) {
+      return reply.status(400).send({
+        success: false,
+        message: error.message || "Invalid skill name format"
+      });
+    }
+    const id = request.body.id || data.name;
+    if (id !== data.name) {
+      return reply.status(400).send({
+        success: false,
+        message: `id "${id}" must equal name "${data.name}" (name is used for path addressing)`
+      });
+    }
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const exists = await skillStore.hasSkill(id);
+    if (exists) {
+      return reply.status(409).send({
+        success: false,
+        message: `Skill with id "${id}" already exists`
+      });
+    }
+    const newSkill = await skillStore.createSkill(id, data);
+    return reply.status(201).send({
+      success: true,
+      message: "Successfully created skill",
+      data: serializeSkill(newSkill)
+    });
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to create skill: ${error.message}`
+    });
+  }
+}
+async function updateSkill(request, reply) {
+  try {
+    const { id } = request.params;
+    const updates = request.body;
+    if (updates.name !== void 0) {
+      try {
+        validateSkillName(updates.name);
+      } catch (error) {
+        return reply.status(400).send({
+          success: false,
+          message: error.message || "Invalid skill name format"
+        });
+      }
+    }
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const exists = await skillStore.hasSkill(id);
+    if (!exists) {
+      return reply.status(404).send({
+        success: false,
+        message: "Skill not found"
+      });
+    }
+    const updatedSkill = await skillStore.updateSkill(id, updates);
+    if (!updatedSkill) {
+      return reply.status(500).send({
+        success: false,
+        message: "Failed to update skill"
+      });
+    }
+    return {
+      success: true,
+      message: "Successfully updated skill",
+      data: serializeSkill(updatedSkill)
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to update skill: ${error.message}`
+    });
+  }
+}
+async function deleteSkill(request, reply) {
+  try {
+    const { id } = request.params;
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const exists = await skillStore.hasSkill(id);
+    if (!exists) {
+      return reply.status(404).send({
+        success: false,
+        message: "Skill not found"
+      });
+    }
+    const deleted = await skillStore.deleteSkill(id);
+    if (!deleted) {
+      return reply.status(500).send({
+        success: false,
+        message: "Failed to delete skill"
+      });
+    }
+    return {
+      success: true,
+      message: "Successfully deleted skill"
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to delete skill: ${error.message}`
+    });
+  }
+}
+async function searchSkillsByMetadata(request, reply) {
+  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 storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.searchByMetadata(key, value);
+    const serializedSkills = skills.map(serializeSkill);
+    return {
+      success: true,
+      message: "Successfully searched skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length
+      }
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to search skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0
+      }
+    });
+  }
+}
+async function filterSkillsByCompatibility(request, reply) {
+  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 storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.filterByCompatibility(compatibility);
+    const serializedSkills = skills.map(serializeSkill);
+    return {
+      success: true,
+      message: "Successfully filtered skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length
+      }
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to filter skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0
+      }
+    });
+  }
+}
+async function filterSkillsByLicense(request, reply) {
+  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 storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.filterByLicense(license);
+    const serializedSkills = skills.map(serializeSkill);
+    return {
+      success: true,
+      message: "Successfully filtered skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length
+      }
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to filter skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0
+      }
+    });
+  }
+}
+
 // src/schemas/index.ts
 var getAllMemoryItemsSchema = {
   description: "Get all memory items for an assistant thread",
@@ -1678,6 +1983,35 @@ var registerLatticeRoutes = (app2) => {
   app2.post("/api/schedules/:taskId/cancel", cancelScheduledTask);
   app2.post("/api/schedules/:taskId/pause", pauseScheduledTask);
   app2.post("/api/schedules/:taskId/resume", resumeScheduledTask);
+  app2.get("/api/skills", getSkillList);
+  app2.get(
+    "/api/skills/:id",
+    getSkill
+  );
+  app2.post(
+    "/api/skills",
+    createSkill
+  );
+  app2.put(
+    "/api/skills/:id",
+    updateSkill
+  );
+  app2.delete(
+    "/api/skills/:id",
+    deleteSkill
+  );
+  app2.get(
+    "/api/skills/search/metadata",
+    searchSkillsByMetadata
+  );
+  app2.get(
+    "/api/skills/filter/compatibility",
+    filterSkillsByCompatibility
+  );
+  app2.get(
+    "/api/skills/filter/license",
+    filterSkillsByLicense
+  );
 };
 
 // src/swagger.ts