@gdrl/kronos-lib 0.1.0

package/dist/react/index.mjs

@@ -0,0 +1,847 @@
+// src/react/useKronos.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useState as useState2 } from "react";
+
+// src/react/KronosProvider.tsx
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useRef,
+  useState
+} from "react";
+import { jsx } from "react/jsx-runtime";
+var KronosContext = createContext(null);
+var REFRESH_BUFFER_MS = 5 * 60 * 1e3;
+function parseTokenExpiry(token) {
+  try {
+    const withoutPrefix = token.startsWith("kr_ft_") ? token.slice(6) : token;
+    const payloadB64 = withoutPrefix.split(".")[0];
+    if (!payloadB64) return null;
+    const base64 = payloadB64.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+    const json = atob(padded);
+    const payload = JSON.parse(json);
+    if (typeof payload.exp === "number") {
+      return payload.exp * 1e3;
+    }
+  } catch {
+  }
+  return null;
+}
+function KronosProvider({ baseUrl, getToken, children }) {
+  const [token, setToken] = useState(null);
+  const [isReady, setIsReady] = useState(false);
+  const timerRef = useRef(null);
+  const getTokenRef = useRef(getToken);
+  getTokenRef.current = getToken;
+  const fetchAndSchedule = useCallback(async () => {
+    try {
+      const newToken = await getTokenRef.current();
+      setToken(newToken);
+      setIsReady(true);
+      if (timerRef.current) clearTimeout(timerRef.current);
+      const expiryMs = parseTokenExpiry(newToken);
+      if (expiryMs) {
+        const delayMs = Math.max(expiryMs - Date.now() - REFRESH_BUFFER_MS, 1e4);
+        timerRef.current = setTimeout(() => {
+          void fetchAndSchedule();
+        }, delayMs);
+      }
+    } catch (err) {
+      console.error("[KronosProvider] Failed to fetch token:", err);
+      setIsReady(true);
+    }
+  }, []);
+  useEffect(() => {
+    void fetchAndSchedule();
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+    };
+  }, [fetchAndSchedule]);
+  const refreshToken = useCallback(async () => {
+    await fetchAndSchedule();
+  }, [fetchAndSchedule]);
+  const value = {
+    baseUrl: baseUrl.replace(/\/$/, ""),
+    token,
+    isReady,
+    refreshToken
+  };
+  return /* @__PURE__ */ jsx(KronosContext.Provider, { value, children });
+}
+function useKronosContext() {
+  return useContext(KronosContext);
+}
+
+// src/react/useKronos.ts
+var INTERNAL_CONTEXT_GRAPH_SKILL_NAME = "__internal_context_graph__";
+async function directFetch(baseUrl, token, path, options = {}) {
+  const res = await fetch(`${baseUrl}${path}`, {
+    method: options.method ?? "GET",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: options.body ? JSON.stringify(options.body) : void 0
+  });
+  const text = await res.text();
+  let data;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+    data = text;
+  }
+  if (!res.ok) {
+    const msg = data && typeof data === "object" && "error" in data && typeof data.error === "string" ? data.error : `Request failed with status ${res.status}`;
+    throw new Error(msg);
+  }
+  return data;
+}
+function parseContextGraphProcedures(files) {
+  return files.filter((file) => file.path.startsWith("procedures/") && file.path.endsWith(".md")).map((file) => {
+    const content = file.content ?? "";
+    const normalized = content.replace(/\r\n/g, "\n");
+    if (normalized.startsWith("---\n")) {
+      const endIndex = normalized.indexOf("\n---\n", 4);
+      if (endIndex !== -1) {
+        const frontmatter = normalized.slice(4, endIndex);
+        const metadata = {};
+        for (const line of frontmatter.split("\n")) {
+          const separatorIndex = line.indexOf(":");
+          if (separatorIndex === -1) continue;
+          const key = line.slice(0, separatorIndex).trim();
+          const value = line.slice(separatorIndex + 1).trim();
+          if (key && value) {
+            metadata[key] = value;
+          }
+        }
+        return {
+          title: metadata.title || (file.path.split("/").pop() ?? file.path),
+          description: metadata.description || "",
+          path: file.path
+        };
+      }
+    }
+    const lines = content.split(/\r?\n/);
+    const titleLine = lines.find((line) => line.startsWith("# "));
+    const title = titleLine ? titleLine.replace(/^#\s+/, "").trim() : file.path.split("/").pop() ?? file.path;
+    const description = lines.slice(1).map((line) => line.trim()).find((line) => line.length > 0 && !line.startsWith("#")) ?? "";
+    return {
+      title,
+      description,
+      path: file.path
+    };
+  }).sort((a, b) => a.path.localeCompare(b.path));
+}
+function assertReadableContextGraphPath(path) {
+  if (path === "SKILL.md") return;
+  if (/^procedures\/[a-z0-9-]+\.md$/.test(path)) return;
+  throw new Error("Only SKILL.md or procedures/*.md paths are allowed");
+}
+function useKronos(args) {
+  const ctx = useKronosContext();
+  const isProvider = !!ctx && !args;
+  const legacyArgs = args;
+  const [triggers, setTriggers] = useState2(null);
+  const [triggersLoading, setTriggersLoading] = useState2(true);
+  const [triggersError, setTriggersError] = useState2(null);
+  const [createLoading, setCreateLoading] = useState2(false);
+  const [createError, setCreateError] = useState2(null);
+  const [updateLoading, setUpdateLoading] = useState2(false);
+  const [updateError, setUpdateError] = useState2(null);
+  const [deleteLoading, setDeleteLoading] = useState2(false);
+  const [deleteError, setDeleteError] = useState2(null);
+  const [memoryStats, setMemoryStats] = useState2(null);
+  const [memoryStatsLoading, setMemoryStatsLoading] = useState2(false);
+  const [memoryStatsError, setMemoryStatsError] = useState2(null);
+  const [scopes, setScopes] = useState2(null);
+  const [scopesLoading, setScopesLoading] = useState2(false);
+  const [scopesError, setScopesError] = useState2(null);
+  const [createScopeLoading, setCreateScopeLoading] = useState2(false);
+  const [createScopeError, setCreateScopeError] = useState2(null);
+  const [updateScopeLoading, setUpdateScopeLoading] = useState2(false);
+  const [updateScopeError, setUpdateScopeError] = useState2(null);
+  const [deleteScopeLoading, setDeleteScopeLoading] = useState2(false);
+  const [deleteScopeError, setDeleteScopeError] = useState2(null);
+  const [skills, setSkills] = useState2(null);
+  const [skillsLoading, setSkillsLoading] = useState2(false);
+  const [skillsError, setSkillsError] = useState2(null);
+  const [createSkillLoading, setCreateSkillLoading] = useState2(false);
+  const [createSkillError, setCreateSkillError] = useState2(null);
+  const [updateSkillLoading, setUpdateSkillLoading] = useState2(false);
+  const [updateSkillError, setUpdateSkillError] = useState2(null);
+  const [deleteSkillLoading, setDeleteSkillLoading] = useState2(false);
+  const [deleteSkillError, setDeleteSkillError] = useState2(null);
+  const loadTriggers = useCallback2(async () => {
+    setTriggersLoading(true);
+    setTriggersError(null);
+    try {
+      let response;
+      if (isProvider && ctx?.token) {
+        response = await directFetch(
+          ctx.baseUrl,
+          ctx.token,
+          "/v1/triggers"
+        );
+      } else if (legacyArgs) {
+        response = await legacyArgs.ops.listTriggers({
+          tenantUserId: legacyArgs.tenantUserId
+        });
+      } else {
+        throw new Error("useKronos: no KronosProvider and no ops provided");
+      }
+      setTriggers(Array.isArray(response.triggers) ? response.triggers : []);
+    } catch (error) {
+      setTriggersError(
+        error instanceof Error ? error.message : "Failed to load Kronos triggers"
+      );
+      setTriggers([]);
+    } finally {
+      setTriggersLoading(false);
+    }
+  }, [isProvider, ctx?.baseUrl, ctx?.token, legacyArgs?.ops, legacyArgs?.tenantUserId]);
+  useEffect2(() => {
+    if (isProvider && !ctx?.isReady) return;
+    void loadTriggers();
+  }, [loadTriggers, isProvider, ctx?.isReady]);
+  const refreshTriggers = useCallback2(async () => {
+    await loadTriggers();
+  }, [loadTriggers]);
+  const createNlTrigger = useCallback2(
+    async (params) => {
+      setCreateLoading(true);
+      setCreateError(null);
+      try {
+        let triggerId = null;
+        if (isProvider && ctx?.token) {
+          const res = await directFetch(
+            ctx.baseUrl,
+            ctx.token,
+            "/v1/triggers",
+            {
+              method: "POST",
+              body: {
+                trigger_type: "nl_webhook",
+                trigger_spec: { nl: params.nl },
+                title: params.title.trim(),
+                action_description: params.actionDescription,
+                webhook_url: ctx.baseUrl + "/v1/triggers/execute",
+                webhook_secret: "frontend-managed"
+              }
+            }
+          );
+          triggerId = res.trigger_id ?? null;
+        } else if (legacyArgs) {
+          const res = await legacyArgs.ops.createNlTrigger({
+            tenantUserId: legacyArgs.tenantUserId,
+            title: params.title,
+            nl: params.nl,
+            actionDescription: params.actionDescription
+          });
+          triggerId = res.triggerId;
+        } else {
+          throw new Error("useKronos: no KronosProvider and no ops provided");
+        }
+        void loadTriggers();
+        return { triggerId };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to create Kronos trigger";
+        setCreateError(message);
+        return { triggerId: null };
+      } finally {
+        setCreateLoading(false);
+      }
+    },
+    [isProvider, ctx?.baseUrl, ctx?.token, legacyArgs?.ops, legacyArgs?.tenantUserId, loadTriggers]
+  );
+  const updateTrigger = useCallback2(
+    async (params) => {
+      setUpdateLoading(true);
+      setUpdateError(null);
+      try {
+        if (!isProvider || !ctx?.token) {
+          throw new Error("updateTrigger requires KronosProvider");
+        }
+        const body = {};
+        if (params.title !== void 0) {
+          body.title = params.title;
+        }
+        if (params.actionDescription !== void 0) {
+          body.action_description = params.actionDescription;
+        }
+        if (params.triggerSpec !== void 0) {
+          body.trigger_spec = params.triggerSpec;
+        }
+        if (params.status !== void 0) {
+          body.status = params.status;
+        }
+        const res = await directFetch(
+          ctx.baseUrl,
+          ctx.token,
+          `/v1/triggers/${encodeURIComponent(params.triggerId)}`,
+          {
+            method: "PUT",
+            body
+          }
+        );
+        void loadTriggers();
+        return res;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to update trigger";
+        setUpdateError(message);
+        throw error;
+      } finally {
+        setUpdateLoading(false);
+      }
+    },
+    [isProvider, ctx?.baseUrl, ctx?.token, loadTriggers]
+  );
+  const deleteTriggerFn = useCallback2(
+    async (params) => {
+      setDeleteLoading(true);
+      setDeleteError(null);
+      try {
+        if (!isProvider || !ctx?.token) {
+          throw new Error("deleteTrigger requires KronosProvider");
+        }
+        const res = await directFetch(
+          ctx.baseUrl,
+          ctx.token,
+          `/v1/triggers/${encodeURIComponent(params.triggerId)}`,
+          { method: "DELETE" }
+        );
+        void loadTriggers();
+        return res;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to delete trigger";
+        setDeleteError(message);
+        throw error;
+      } finally {
+        setDeleteLoading(false);
+      }
+    },
+    [isProvider, ctx?.baseUrl, ctx?.token, loadTriggers]
+  );
+  const loadMemoryStats = useCallback2(async () => {
+    if (!isProvider || !ctx?.token) return;
+    setMemoryStatsLoading(true);
+    setMemoryStatsError(null);
+    try {
+      const res = await directFetch(
+        ctx.baseUrl,
+        ctx.token,
+        "/v1/memory-stats"
+      );
+      setMemoryStats(res);
+    } catch (error) {
+      setMemoryStatsError(
+        error instanceof Error ? error.message : "Failed to load memory stats"
+      );
+    } finally {
+      setMemoryStatsLoading(false);
+    }
+  }, [isProvider, ctx?.baseUrl, ctx?.token]);
+  const refreshMemoryStats = useCallback2(async () => {
+    await loadMemoryStats();
+  }, [loadMemoryStats]);
+  const loadScopes = useCallback2(async () => {
+    if (!isProvider || !ctx?.token) return;
+    setScopesLoading(true);
+    setScopesError(null);
+    try {
+      const res = await directFetch(
+        ctx.baseUrl,
+        ctx.token,
+        "/v1/scopes"
+      );
+      setScopes(Array.isArray(res.scopes) ? res.scopes : []);
+    } catch (error) {
+      setScopesError(
+        error instanceof Error ? error.message : "Failed to load scopes"
+      );
+      setScopes([]);
+    } finally {
+      setScopesLoading(false);
+    }
+  }, [isProvider, ctx?.baseUrl, ctx?.token]);
+  const refreshScopes = useCallback2(async () => {
+    await loadScopes();
+  }, [loadScopes]);
+  const getMCPServer = useCallback2(
+    async (params) => {
+      if (!isProvider || !ctx?.token) {
+        throw new Error("getMCPServer requires KronosProvider");
+      }
+      return directFetch(
+        ctx.baseUrl,
+        ctx.token,
+        `/v1/mcp-servers/${encodeURIComponent(params.serverId)}`
+      );
+    },
+    [isProvider, ctx?.baseUrl, ctx?.token]
+  );
+  const connectMCPServer = useCallback2(
+    async (params) => {
+      if (!isProvider || !ctx?.token) {
+        throw new Error("connectMCPServer requires KronosProvider");
+      }
+      return directFetch(
+        ctx.baseUrl,
+        ctx.token,
+        `/v1/mcp-servers/${encodeURIComponent(params.serverId)}/connect`,
+        {
+          method: "POST",
+          body: {}
+        }
+      );
+    },
+    [isProvider, ctx?.baseUrl, ctx?.token]
+  );
+  const createScope = useCallback2(
+    async (params) => {
+      setCreateScopeLoading(true);
+      setCreateScopeError(null);
+      try {
+        if (!isProvider || !ctx?.token) {
+          throw new Error("createScope requires KronosProvider");
+        }
+        const res = await directFetch(
+          ctx.baseUrl,
+          ctx.token,
+          "/v1/scopes",
+          {
+            method: "POST",
+            body: {
+              name: params.name,
+              include_query: params.include_query,
+              description: params.description
+            }
+          }
+        );
+        void loadScopes();
+        if (res.mcp_server_error) {
+          setCreateScopeError(res.mcp_server_error);
+        }
+        return {
+          scope_id: res.scope_id ?? null,
+          backfill_job_id: res.backfill_job_id,
+          mcp_server_id: res.mcp_server_id ?? null,
+          mcp_server_error: res.mcp_server_error ?? null
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to create scope";
+        setCreateScopeError(message);
+        return { scope_id: null, mcp_server_id: null, mcp_server_error: message };
+      } finally {
+        setCreateScopeLoading(false);
+      }
+    },
+    [isProvider, ctx?.baseUrl, ctx?.token, loadScopes]
+  );
+  const updateScopeFn = useCallback2(
+    async (params) => {
+      setUpdateScopeLoading(true);
+      setUpdateScopeError(null);
+      try {
+        if (!isProvider || !ctx?.token) {
+          throw new Error("updateScope requires KronosProvider");
+        }
+        const res = await directFetch(
+          ctx.baseUrl,
+          ctx.token,
+          `/v1/scopes/${encodeURIComponent(params.scopeId)}`,
+          {
+            method: "PATCH",
+            body: params.patch
+          }
+        );
+        void loadScopes();
+        return res;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to update scope";
+        setUpdateScopeError(message);
+        throw error;
+      } finally {
+        setUpdateScopeLoading(false);
+      }
+    },
+    [isProvider, ctx?.baseUrl, ctx?.token, loadScopes]
+  );
+  const deleteScopeFn = useCallback2(
+    async (params) => {
+      setDeleteScopeLoading(true);
+      setDeleteScopeError(null);
+      try {
+        if (!isProvider || !ctx?.token) {
+          throw new Error("deleteScope requires KronosProvider");
+        }
+        const res = await directFetch(
+          ctx.baseUrl,
+          ctx.token,
+          `/v1/scopes/${encodeURIComponent(params.scopeId)}`,
+          { method: "DELETE" }
+        );
+        void loadScopes();
+        return res;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to delete scope";
+        setDeleteScopeError(message);
+        throw error;
+      } finally {
+        setDeleteScopeLoading(false);
+      }
+    },
+    [isProvider, ctx?.baseUrl, ctx?.token, loadScopes]
+  );
+  const refreshSkills = useCallback2(async () => {
+    setSkillsLoading(true);
+    setSkillsError(null);
+    try {
+      if (!isProvider || !ctx?.token) {
+        throw new Error("refreshSkills requires KronosProvider");
+      }
+      const res = await directFetch(
+        ctx.baseUrl,
+        ctx.token,
+        "/v1/skills/manage",
+        {
+          method: "POST",
+          body: {
+            operation: "list"
+          }
+        }
+      );
+      setSkills(Array.isArray(res.skills) ? res.skills : []);
+    } catch (error) {
+      setSkillsError(
+        error instanceof Error ? error.message : "Failed to load skills"
+      );
+      setSkills([]);
+    } finally {
+      setSkillsLoading(false);
+    }
+  }, [isProvider, ctx?.baseUrl, ctx?.token]);
+  const createSkill = useCallback2(
+    async (params) => {
+      setCreateSkillLoading(true);
+      setCreateSkillError(null);
+      try {
+        if (!isProvider || !ctx?.token) {
+          throw new Error("createSkill requires KronosProvider");
+        }
+        const res = await directFetch(
+          ctx.baseUrl,
+          ctx.token,
+          "/v1/skills/manage",
+          {
+            method: "POST",
+            body: {
+              operation: "create",
+              name: params.name.trim(),
+              description: params.description.trim(),
+              instructions: params.instructions,
+              files: params.files,
+              metadata: params.metadata
+            }
+          }
+        );
+        void refreshSkills();
+        return { skillId: res.skill_id ?? null };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to create skill";
+        setCreateSkillError(message);
+        return { skillId: null };
+      } finally {
+        setCreateSkillLoading(false);
+      }
+    },
+    [isProvider, ctx?.baseUrl, ctx?.token, refreshSkills]
+  );
+  const readSkill = useCallback2(
+    async (params) => {
+      if (!isProvider || !ctx?.token) {
+        throw new Error("readSkill requires KronosProvider");
+      }
+      return directFetch(
+        ctx.baseUrl,
+        ctx.token,
+        "/v1/skills/manage",
+        {
+          method: "POST",
+          body: {
+            operation: "read",
+            skill_id: params.skillId,
+            mode: params.mode,
+            files: params.files,
+            fileContent: params.fileContent
+          }
+        }
+      );
+    },
+    [isProvider, ctx?.baseUrl, ctx?.token]
+  );
+  const updateSkill = useCallback2(
+    async (params) => {
+      setUpdateSkillLoading(true);
+      setUpdateSkillError(null);
+      try {
+        if (!isProvider || !ctx?.token) {
+          throw new Error("updateSkill requires KronosProvider");
+        }
+        const res = await directFetch(
+          ctx.baseUrl,
+          ctx.token,
+          "/v1/skills/manage",
+          {
+            method: "POST",
+            body: {
+              operation: "update",
+              skill_id: params.skillId,
+              patch: params.patch
+            }
+          }
+        );
+        void refreshSkills();
+        return res;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to update skill";
+        setUpdateSkillError(message);
+        throw error;
+      } finally {
+        setUpdateSkillLoading(false);
+      }
+    },
+    [isProvider, ctx?.baseUrl, ctx?.token, refreshSkills]
+  );
+  const deleteSkill = useCallback2(
+    async (params) => {
+      setDeleteSkillLoading(true);
+      setDeleteSkillError(null);
+      try {
+        if (!isProvider || !ctx?.token) {
+          throw new Error("deleteSkill requires KronosProvider");
+        }
+        const res = await directFetch(
+          ctx.baseUrl,
+          ctx.token,
+          "/v1/skills/manage",
+          {
+            method: "POST",
+            body: {
+              operation: "delete",
+              skill_id: params.skillId
+            }
+          }
+        );
+        void refreshSkills();
+        return res;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to delete skill";
+        setDeleteSkillError(message);
+        throw error;
+      } finally {
+        setDeleteSkillLoading(false);
+      }
+    },
+    [isProvider, ctx?.baseUrl, ctx?.token, refreshSkills]
+  );
+  const getContextGraph = useCallback2(async () => {
+    if (!isProvider || !ctx?.token) {
+      throw new Error("getContextGraph requires KronosProvider");
+    }
+    const listed = await directFetch(
+      ctx.baseUrl,
+      ctx.token,
+      "/v1/skills/manage",
+      {
+        method: "POST",
+        body: {
+          operation: "list",
+          include_internal: true
+        }
+      }
+    );
+    const match = (listed.skills ?? []).find(
+      (skill) => skill.name === INTERNAL_CONTEXT_GRAPH_SKILL_NAME
+    );
+    if (!match?.skill_id) {
+      return {
+        skill_id: null,
+        procedures: []
+      };
+    }
+    const treeResult = await directFetch(
+      ctx.baseUrl,
+      ctx.token,
+      "/v1/skills/manage",
+      {
+        method: "POST",
+        body: {
+          operation: "read",
+          skill_id: match.skill_id,
+          mode: "tree"
+        }
+      }
+    );
+    const procedurePaths = (treeResult.tree ?? []).filter(
+      (node) => node.kind === "file" && node.path.startsWith("procedures/") && node.path.endsWith(".md")
+    ).map((node) => node.path);
+    if (procedurePaths.length === 0) {
+      return {
+        skill_id: match.skill_id,
+        procedures: []
+      };
+    }
+    const filesResult = await directFetch(
+      ctx.baseUrl,
+      ctx.token,
+      "/v1/skills/manage",
+      {
+        method: "POST",
+        body: {
+          operation: "read",
+          skill_id: match.skill_id,
+          mode: "files",
+          files: procedurePaths,
+          fileContent: "full"
+        }
+      }
+    );
+    return {
+      skill_id: match.skill_id,
+      procedures: parseContextGraphProcedures(filesResult.files ?? [])
+    };
+  }, [isProvider, ctx?.baseUrl, ctx?.token]);
+  const readContextGraph = useCallback2(
+    async (params) => {
+      if (!isProvider || !ctx?.token) {
+        throw new Error("readContextGraph requires KronosProvider");
+      }
+      const requestedPath = params?.path?.trim() || "SKILL.md";
+      assertReadableContextGraphPath(requestedPath);
+      const listed = await directFetch(
+        ctx.baseUrl,
+        ctx.token,
+        "/v1/skills/manage",
+        {
+          method: "POST",
+          body: {
+            operation: "list",
+            include_internal: true
+          }
+        }
+      );
+      const match = (listed.skills ?? []).find(
+        (skill) => skill.name === INTERNAL_CONTEXT_GRAPH_SKILL_NAME
+      );
+      if (!match?.skill_id) {
+        return {
+          skill_id: null,
+          path: requestedPath,
+          content: null
+        };
+      }
+      if (requestedPath === "SKILL.md") {
+        const result2 = await directFetch(
+          ctx.baseUrl,
+          ctx.token,
+          "/v1/skills/manage",
+          {
+            method: "POST",
+            body: {
+              operation: "read",
+              skill_id: match.skill_id,
+              mode: "instructions"
+            }
+          }
+        );
+        return {
+          skill_id: match.skill_id,
+          path: "SKILL.md",
+          content: result2.instructions ?? null
+        };
+      }
+      const result = await directFetch(
+        ctx.baseUrl,
+        ctx.token,
+        "/v1/skills/manage",
+        {
+          method: "POST",
+          body: {
+            operation: "read",
+            skill_id: match.skill_id,
+            mode: "files",
+            files: [requestedPath],
+            fileContent: "full"
+          }
+        }
+      );
+      const file = (result.files ?? []).find(
+        (entry) => entry.path === requestedPath
+      );
+      return {
+        skill_id: match.skill_id,
+        path: requestedPath,
+        content: file?.content ?? null
+      };
+    },
+    [isProvider, ctx?.baseUrl, ctx?.token]
+  );
+  return {
+    triggers,
+    triggersLoading,
+    triggersError,
+    refreshTriggers,
+    createNlTrigger,
+    createLoading,
+    createError,
+    updateTrigger,
+    updateLoading,
+    updateError,
+    deleteTrigger: deleteTriggerFn,
+    deleteLoading,
+    deleteError,
+    memoryStats,
+    memoryStatsLoading,
+    memoryStatsError,
+    refreshMemoryStats,
+    scopes,
+    scopesLoading,
+    scopesError,
+    refreshScopes,
+    getMCPServer,
+    connectMCPServer,
+    createScope,
+    createScopeLoading,
+    createScopeError,
+    updateScope: updateScopeFn,
+    updateScopeLoading,
+    updateScopeError,
+    deleteScope: deleteScopeFn,
+    deleteScopeLoading,
+    deleteScopeError,
+    skills,
+    skillsLoading,
+    skillsError,
+    refreshSkills,
+    createSkill,
+    createSkillLoading,
+    createSkillError,
+    readSkill,
+    updateSkill,
+    updateSkillLoading,
+    updateSkillError,
+    deleteSkill,
+    deleteSkillLoading,
+    deleteSkillError,
+    getContextGraph,
+    readContextGraph
+  };
+}
+export {
+  KronosProvider,
+  useKronos,
+  useKronosContext
+};
+//# sourceMappingURL=index.mjs.map