@krak-stack/registry 0.1.2 → 0.1.4

package/dist/lib/query.js

@@ -0,0 +1,128 @@
+// ../../src/lib/query.ts
+import {
+  Effect,
+  Option,
+  Schema,
+  SchemaIssue,
+  SchemaTransformation
+} from "effect";
+var parseSortParam = (sort) => {
+  const id = sort.startsWith("-") ? sort.slice(1) : sort;
+  if (!id || id.includes(",") || id.includes(":")) {
+    return null;
+  }
+  return { id, direction: sort.startsWith("-") ? "desc" : "asc" };
+};
+var SortDirection = Schema.Union([
+  Schema.Literal("asc"),
+  Schema.Literal("desc")
+]).pipe(Schema.annotate({
+  identifier: "SortDirection",
+  title: "Sort Direction",
+  description: "Sort direction for list query results.",
+  examples: ["asc", "desc"]
+}));
+var SortParam = Schema.Struct({
+  id: Schema.NonEmptyString,
+  direction: SortDirection
+}).pipe(Schema.annotate({
+  identifier: "SortParam",
+  title: "Sort Parameter",
+  description: "Decoded sort parameter with a field id and direction.",
+  examples: [{ id: "publicName", direction: "asc" }]
+}));
+var SortParamFromString = Schema.String.pipe(Schema.decodeTo(SortParam, SchemaTransformation.transformOrFail({
+  decode: (sort) => {
+    const sortParam = parseSortParam(sort);
+    if (!sortParam) {
+      return Effect.fail(new SchemaIssue.InvalidValue(Option.some(sort), {
+        message: 'Expected sort in the format "field" or "-field"'
+      }));
+    }
+    return Effect.succeed(sortParam);
+  },
+  encode: (sort) => Effect.succeed(sort.direction === "desc" ? `-${sort.id}` : sort.id)
+})), Schema.annotate({
+  identifier: "SortParamFromString",
+  title: "Sort Parameter From String",
+  description: 'URL encoded single sort parameter where descending fields are prefixed with "-".',
+  examples: [{ id: "publicName", direction: "asc" }]
+}));
+var SortParamsFromString = Schema.String.pipe(Schema.decodeTo(Schema.Array(SortParam), SchemaTransformation.transformOrFail({
+  decode: (sort) => {
+    const parts = sort.split(",");
+    const sortParams = [];
+    for (const part of parts) {
+      const sortParam = parseSortParam(part);
+      if (!sortParam) {
+        return Effect.fail(new SchemaIssue.InvalidValue(Option.some(sort), {
+          message: 'Expected sort in the format "field,-otherField"'
+        }));
+      }
+      sortParams.push(sortParam);
+    }
+    return Effect.succeed(sortParams);
+  },
+  encode: (sort) => Effect.succeed(sort.map((part) => Schema.encodeSync(SortParamFromString)(part)).join(","))
+})), Schema.annotate({
+  identifier: "SortParamsFromString",
+  title: "Sort Parameters From String",
+  description: 'URL encoded sort parameters where descending fields are prefixed with "-" and multiple fields are comma-separated.',
+  examples: [
+    [
+      { id: "name", direction: "desc" },
+      { id: "age", direction: "asc" }
+    ]
+  ]
+}));
+var SortParamSearch = SortParamsFromString.pipe(Schema.decodeTo(Schema.String, SchemaTransformation.transform({
+  decode: (sort) => Schema.encodeSync(SortParamsFromString)(sort),
+  encode: (sort) => Schema.decodeUnknownSync(SortParamsFromString)(sort)
+})), Schema.annotate({
+  identifier: "SortParamSearch",
+  title: "Sort Search Parameter",
+  description: 'Search parameter sort value normalized to the compact "-field,otherField" URL format.',
+  examples: ["-name,age"]
+}));
+var Query = Schema.Struct({
+  page: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+  pageSize: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 100 })),
+  globalFilter: Schema.optional(Schema.String),
+  sort: Schema.optional(SortParamSearch)
+}).annotate({
+  identifier: "Query",
+  title: "Query",
+  description: "Zero-based page request parameters with optional filtering and sorting for list endpoints.",
+  examples: [
+    {
+      page: 0,
+      pageSize: 10,
+      globalFilter: "housing",
+      sort: "-publicName,createdAt"
+    }
+  ]
+});
+var PaginationMeta = Schema.Struct({
+  page: Schema.Int,
+  pageSize: Schema.Int,
+  total: Schema.Int,
+  pageCount: Schema.Int
+}).pipe(Schema.annotate({
+  identifier: "PaginationMeta",
+  title: "Pagination Metadata",
+  description: "Pagination metadata returned with a paginated list response.",
+  examples: [{ page: 0, pageSize: 10, total: 125, pageCount: 13 }]
+}));
+var PaginatedResponse = (items) => Schema.Struct({
+  data: Schema.Array(items),
+  meta: PaginationMeta
+});
+export {
+  SortParamsFromString,
+  SortParamFromString,
+  SortParam,
+  SortDirection,
+  Query,
+  PaginationMeta,
+  PaginatedResponse
+};

package/dist/services/agent/client/atom.d.ts

@@ -0,0 +1,56 @@
+import { Effect, Stream } from "effect";
+import { Atom, Reactivity } from "effect/unstable/reactivity";
+import type { AgentErrorCode, AgentEvent, AgentReference, AgentRequest } from "../schema.js";
+export type AgentToolStatus = "running" | "approval-required" | "approved" | "denied" | "completed" | "failed";
+export type AgentToolActivity = Extract<AgentEvent, {
+    readonly type: "tool-call";
+}> & {
+    readonly approvalId?: string;
+    readonly status: AgentToolStatus;
+};
+export type AgentMessage = {
+    readonly id: string;
+    readonly role: "user" | "assistant";
+    readonly text: string;
+    readonly tools: ReadonlyArray<AgentToolActivity>;
+};
+export type AgentSubmitAction<Resource = never> = {
+    readonly type: "message";
+    readonly text: string;
+    readonly references?: ReadonlyArray<AgentReference<Resource>>;
+} | {
+    readonly type: "approval";
+    readonly approvalId: string;
+    readonly toolCallId: string;
+    readonly approved: boolean;
+};
+export type AgentConversationContext<Resource> = AgentReference<Resource> & {
+    readonly key: string;
+};
+export type AgentState<Resource = never> = {
+    readonly context: AgentConversationContext<Resource> | undefined;
+    readonly contextLocked: boolean;
+    readonly messages: ReadonlyArray<AgentMessage>;
+    readonly history?: string;
+    readonly pending: boolean;
+    readonly error?: AgentErrorCode;
+};
+export declare const initialAgentState: AgentState<never>;
+export declare const reduceAgentEvent: <Resource>(state: AgentState<Resource>, event: AgentEvent) => AgentState<Resource>;
+export type AgentAtomsConfig<Resource> = {
+    readonly stream: (get: Atom.FnContext, request: AgentRequest<Resource>) => Effect.Effect<Stream.Stream<AgentEvent, unknown, Reactivity.Reactivity>, unknown>;
+    readonly errorCode?: (error: unknown) => AgentErrorCode;
+    readonly reactivityKeys?: ReadonlyArray<unknown>;
+    readonly runtime?: Atom.AtomRuntime<never>;
+};
+export type AgentSubmitInput<Resource> = {
+    readonly action: AgentSubmitAction<Resource>;
+    readonly context?: AgentConversationContext<Resource>;
+    readonly scope: string;
+};
+export declare const makeAgentAtoms: <Resource>({ errorCode, reactivityKeys, runtime, stream, }: AgentAtomsConfig<Resource>) => {
+    readonly removeContext: Atom.Writable<import("effect/Option").Option<void>, string>;
+    readonly reset: Atom.Writable<import("effect/Option").Option<void>, string>;
+    readonly state: (arg: string) => Atom.Writable<AgentState<Resource>, AgentState<Resource>>;
+    readonly submit: Atom.AtomResultFn<AgentSubmitInput<Resource>, void, never>;
+};

package/dist/services/agent/client/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./atom.js";
+export * from "./widget.js";