@mepuka/skygent 0.2.0 → 0.3.1

package/src/graph/relationships.ts

@@ -0,0 +1,129 @@
+import { Graph, Option } from "effect";
+import type { RelationshipView } from "../domain/bsky.js";
+
+export type RelationshipNode = {
+  readonly did?: string;
+  readonly handle?: string;
+  readonly displayName?: string;
+  readonly inputs: ReadonlyArray<string>;
+  readonly notFound?: boolean;
+};
+
+export type RelationshipEdge = {
+  readonly following: boolean;
+  readonly followedBy: boolean;
+  readonly mutual: boolean;
+  readonly blocking: boolean;
+  readonly blockedBy: boolean;
+  readonly blockingByList: boolean;
+  readonly blockedByList: boolean;
+  readonly notFound: boolean;
+};
+
+export type RelationshipEntry = {
+  readonly actor: RelationshipNode;
+  readonly other: RelationshipNode;
+  readonly relationship: RelationshipEdge;
+};
+
+export type RelationshipGraphResult = {
+  readonly graph: Graph.DirectedGraph<RelationshipNode, RelationshipEdge>;
+  readonly actorIndex: Graph.NodeIndex;
+  readonly nodeIndexByKey: Map<string, Graph.NodeIndex>;
+};
+
+const edgeFromRelationship = (relationship: RelationshipView): RelationshipEdge => {
+  if (!("did" in relationship)) {
+    return {
+      following: false,
+      followedBy: false,
+      mutual: false,
+      blocking: false,
+      blockedBy: false,
+      blockingByList: false,
+      blockedByList: false,
+      notFound: true
+    };
+  }
+  const following = typeof relationship.following === "string";
+  const followedBy = typeof relationship.followedBy === "string";
+  const blocking = typeof relationship.blocking === "string";
+  const blockedBy = typeof relationship.blockedBy === "string";
+  const blockingByList = typeof relationship.blockingByList === "string";
+  const blockedByList = typeof relationship.blockedByList === "string";
+  return {
+    following,
+    followedBy,
+    mutual: following && followedBy,
+    blocking,
+    blockedBy,
+    blockingByList,
+    blockedByList,
+    notFound: false
+  };
+};
+
+const nodeFromKey = (key: string): RelationshipNode => ({
+  ...(key.startsWith("did:") ? { did: key } : {}),
+  inputs: [key],
+  notFound: true
+});
+
+export const buildRelationshipGraph = (
+  actorKey: string,
+  nodesByKey: Map<string, RelationshipNode>,
+  relationships: ReadonlyArray<RelationshipView>
+): RelationshipGraphResult => {
+  const base = Graph.directed<RelationshipNode, RelationshipEdge>();
+  const nodeIndexByKey = new Map<string, Graph.NodeIndex>();
+
+  const graph = Graph.mutate(base, (mutable) => {
+    const actorNode = nodesByKey.get(actorKey) ?? nodeFromKey(actorKey);
+    const actorIndex = Graph.addNode(mutable, actorNode);
+    nodeIndexByKey.set(actorKey, actorIndex);
+
+    const ensureNode = (key: string, node: RelationshipNode) => {
+      const existing = nodeIndexByKey.get(key);
+      if (existing !== undefined) {
+        return existing;
+      }
+      const index = Graph.addNode(mutable, node);
+      nodeIndexByKey.set(key, index);
+      return index;
+    };
+
+    for (const relationship of relationships) {
+      const key = "did" in relationship ? relationship.did : relationship.actor;
+      const node = nodesByKey.get(key) ?? nodeFromKey(key);
+      const otherIndex = ensureNode(key, node);
+      Graph.addEdge(mutable, actorIndex, otherIndex, edgeFromRelationship(relationship));
+    }
+  });
+
+  const actorIndex = nodeIndexByKey.get(actorKey);
+  if (actorIndex === undefined) {
+    throw new Error(`Missing actor node for ${actorKey}`);
+  }
+
+  return { graph, actorIndex, nodeIndexByKey };
+};
+
+export const relationshipEntries = (
+  graph: Graph.DirectedGraph<RelationshipNode, RelationshipEdge>
+): ReadonlyArray<RelationshipEntry> => {
+  const edges = Array.from(Graph.values(Graph.edges(graph)));
+  const entries: RelationshipEntry[] = [];
+  for (const edge of edges) {
+    const actor = Option.getOrUndefined(Graph.getNode(graph, edge.source));
+    const other = Option.getOrUndefined(Graph.getNode(graph, edge.target));
+    if (!actor || !other) {
+      continue;
+    }
+    entries.push({ actor, other, relationship: edge.data });
+  }
+  return entries;
+};
+
+export const relationshipMermaid = (
+  graph: Graph.DirectedGraph<RelationshipNode, RelationshipEdge>
+): string => Graph.toMermaid(graph);

package/src/services/bsky-client.ts

@@ -1256,6 +1256,7 @@ export class BskyClient extends Context.Tag("@skygent/BskyClient")<
       const config = yield* AppConfigService;
       const credentials = yield* CredentialStore;
       const agent = new AtpAgent({ service: config.service });
+      const publicAgent = new AtpAgent({ service: "https://public.api.bsky.app" });
 
       const minInterval = yield* Config.duration("SKYGENT_BSKY_RATE_LIMIT").pipe(
         Config.withDefault(Duration.millis(250))
@@ -1507,6 +1508,7 @@ export class BskyClient extends Context.Tag("@skygent/BskyClient")<
       const getFollowers = (actor: string, opts?: GraphOptions) =>
         Effect.gen(function* () {
           yield* ensureAuth(false);
+          const api = agent.hasSession ? agent : publicAgent;
           const params = withCursor(
             { actor, limit: opts?.limit ?? 50 },
             opts?.cursor
@@ -1514,7 +1516,7 @@ export class BskyClient extends Context.Tag("@skygent/BskyClient")<
           const response = yield* withRetry(
             withRateLimit(
               Effect.tryPromise<AppBskyGraphGetFollowers.Response>(() =>
-                agent.app.bsky.graph.getFollowers(params)
+                api.app.bsky.graph.getFollowers(params)
               )
             )
           ).pipe(Effect.mapError(toBskyError("Failed to fetch followers", "getFollowers")));
@@ -1531,6 +1533,7 @@ export class BskyClient extends Context.Tag("@skygent/BskyClient")<
       const getFollows = (actor: string, opts?: GraphOptions) =>
         Effect.gen(function* () {
           yield* ensureAuth(false);
+          const api = agent.hasSession ? agent : publicAgent;
           const params = withCursor(
             { actor, limit: opts?.limit ?? 50 },
             opts?.cursor
@@ -1538,7 +1541,7 @@ export class BskyClient extends Context.Tag("@skygent/BskyClient")<
           const response = yield* withRetry(
             withRateLimit(
               Effect.tryPromise<AppBskyGraphGetFollows.Response>(() =>
-                agent.app.bsky.graph.getFollows(params)
+                api.app.bsky.graph.getFollows(params)
               )
             )
           ).pipe(Effect.mapError(toBskyError("Failed to fetch follows", "getFollows")));
@@ -1582,10 +1585,11 @@ export class BskyClient extends Context.Tag("@skygent/BskyClient")<
             return { actor, relationships: [] };
           }
           yield* ensureAuth(false);
+          const api = agent.hasSession ? agent : publicAgent;
           const response = yield* withRetry(
             withRateLimit(
               Effect.tryPromise<AppBskyGraphGetRelationships.Response>(() =>
-                agent.app.bsky.graph.getRelationships({ actor, others: [...others] })
+                api.app.bsky.graph.getRelationships({ actor, others: [...others] })
               )
             )
           ).pipe(Effect.mapError(toBskyError("Failed to fetch relationships", "getRelationships")));
@@ -1602,6 +1606,7 @@ export class BskyClient extends Context.Tag("@skygent/BskyClient")<
       const getList = (uri: string, opts?: GraphOptions) =>
         Effect.gen(function* () {
           yield* ensureAuth(false);
+          const api = agent.hasSession ? agent : publicAgent;
           const params = withCursor(
             { list: uri, limit: opts?.limit ?? 50 },
             opts?.cursor
@@ -1609,7 +1614,7 @@ export class BskyClient extends Context.Tag("@skygent/BskyClient")<
           const response = yield* withRetry(
             withRateLimit(
               Effect.tryPromise<AppBskyGraphGetList.Response>(() =>
-                agent.app.bsky.graph.getList(params)
+                api.app.bsky.graph.getList(params)
               )
             )
           ).pipe(Effect.mapError(toBskyError("Failed to fetch list", "getList")));
@@ -1626,6 +1631,7 @@ export class BskyClient extends Context.Tag("@skygent/BskyClient")<
       const getLists = (actor: string, opts?: GraphListsOptions) =>
         Effect.gen(function* () {
           yield* ensureAuth(false);
+          const api = agent.hasSession ? agent : publicAgent;
           const params = withCursor(
             {
               actor,
@@ -1639,7 +1645,7 @@ export class BskyClient extends Context.Tag("@skygent/BskyClient")<
           const response = yield* withRetry(
             withRateLimit(
               Effect.tryPromise<AppBskyGraphGetLists.Response>(() =>
-                agent.app.bsky.graph.getLists(params)
+                api.app.bsky.graph.getLists(params)
               )
             )
           ).pipe(Effect.mapError(toBskyError("Failed to fetch lists", "getLists")));

package/src/services/jetstream-sync.ts

@@ -583,10 +583,10 @@ export class JetstreamSyncEngine extends Context.Tag("@skygent/JetstreamSyncEngi
                 Stream.interruptWhen(
                   Effect.sleep(config.duration).pipe(
                     Effect.zipRight(
-                      Effect.logWarning(
-                        "Jetstream sync exceeded duration; shutting down.",
-                        { durationMs: Duration.toMillis(config.duration) }
-                      )
+                      reporter.warn("Jetstream sync exceeded duration; shutting down.", {
+                        durationMs: Duration.toMillis(config.duration),
+                        store: config.store.name
+                      })
                     ),
                     Effect.zipRight(safeShutdown)
                   )

package/src/services/lineage-store.ts

@@ -63,6 +63,14 @@ export class LineageStore extends Context.Tag("@skygent/LineageStore")<
      * @returns Effect resolving to void, or StoreIoError on failure
      */
     readonly save: (lineage: StoreLineage) => Effect.Effect<void, StoreIoError>;
+
+    /**
+     * Removes lineage information for a store.
+     *
+     * @param storeName - The name of the store to remove lineage for
+     * @returns Effect resolving to void, or StoreIoError on failure
+     */
+    readonly remove: (storeName: StoreName) => Effect.Effect<void, StoreIoError>;
   }
 >() {
   static readonly layer = Layer.effect(
@@ -83,7 +91,13 @@ export class LineageStore extends Context.Tag("@skygent/LineageStore")<
           .pipe(Effect.mapError(toStoreIoError(lineage.storeName)))
       );
 
-      return LineageStore.of({ get, save });
+      const remove = Effect.fn("LineageStore.remove")((storeName: StoreName) =>
+        lineages
+          .remove(lineageKey(storeName))
+          .pipe(Effect.mapError(toStoreIoError(storeName)))
+      );
+
+      return LineageStore.of({ get, save, remove });
     })
   );
 }

package/src/services/shared.ts

@@ -19,10 +19,57 @@ export const pickDefined = <T extends Record<string, unknown>>(input: T): Partia
     Object.entries(input).filter(([, value]) => value !== undefined)
   ) as Partial<T>;
 
+type FormatParseErrorOptions = {
+  readonly label?: string;
+  readonly maxIssues?: number;
+};
+
+const formatPath = (path: ReadonlyArray<unknown>) =>
+  path.length > 0 ? path.map((entry) => String(entry)).join(".") : "value";
+
+export const formatParseError = (
+  error: ParseResult.ParseError,
+  options?: FormatParseErrorOptions
+) => {
+  const issues = ParseResult.ArrayFormatter.formatErrorSync(error);
+  if (issues.length === 0) {
+    return ParseResult.TreeFormatter.formatErrorSync(error);
+  }
+
+  const jsonParseIssue = issues.find(
+    (issue) =>
+      issue._tag === "Transformation" &&
+      typeof issue.message === "string" &&
+      issue.message.startsWith("JSON Parse error")
+  );
+  if (jsonParseIssue) {
+    const header = options?.label
+      ? `Invalid JSON input for ${options.label}.`
+      : "Invalid JSON input.";
+    return [
+      header,
+      jsonParseIssue.message,
+      "Tip: wrap JSON in single quotes to avoid shell escaping issues."
+    ].join("\n");
+  }
+
+  const maxIssues = options?.maxIssues ?? 6;
+  const lines = issues.slice(0, maxIssues).map((issue) => {
+    const path = formatPath(issue.path);
+    return `${path}: ${issue.message}`;
+  });
+  if (issues.length > maxIssues) {
+    lines.push(`Additional issues: ${issues.length - maxIssues}`);
+  }
+
+  const header = options?.label ? `Invalid ${options.label}.` : undefined;
+  return header ? [header, ...lines].join("\n") : lines.join("\n");
+};
+
 /** Format a Schema parse error (or arbitrary unknown) as a readable string. */
 export const formatSchemaError = (error: unknown) => {
   if (ParseResult.isParseError(error)) {
-    return ParseResult.TreeFormatter.formatErrorSync(error);
+    return formatParseError(error);
   }
   return String(error);
 };

package/src/services/store-cleaner.ts

@@ -11,7 +11,10 @@ export class StoreCleaner extends Context.Tag("@skygent/StoreCleaner")<
   {
     readonly deleteStore: (
       name: StoreName
-    ) => Effect.Effect<{ readonly deleted: boolean }, StoreError>;
+    ) => Effect.Effect<
+      { readonly deleted: boolean; readonly reason?: "missing" },
+      StoreError
+    >;
   }
 >() {
   static readonly layer = Layer.effect(
@@ -26,7 +29,7 @@ export class StoreCleaner extends Context.Tag("@skygent/StoreCleaner")<
         Effect.gen(function* () {
           const storeOption = yield* manager.getStore(name);
           if (Option.isNone(storeOption)) {
-            return { deleted: false } as const;
+            return { deleted: false, reason: "missing" } as const;
           }
           const store = storeOption.value;
           yield* eventLog.clear(store);

package/src/services/store-commit.ts

@@ -67,6 +67,13 @@ export class StoreCommitter extends Context.Tag("@skygent/StoreCommitter")<
       store: StoreRef,
       event: PostUpsert
     ) => Effect.Effect<EventLogEntry, StoreIoError>;
+    /**
+     * Append multiple upsert events in a single transaction.
+     */
+    readonly appendUpserts: (
+      store: StoreRef,
+      events: ReadonlyArray<PostUpsert>
+    ) => Effect.Effect<ReadonlyArray<EventLogEntry>, StoreIoError>;
 
     /**
      * Append an upsert event only if the post doesn't already exist.
@@ -84,6 +91,13 @@ export class StoreCommitter extends Context.Tag("@skygent/StoreCommitter")<
       store: StoreRef,
       event: PostUpsert
     ) => Effect.Effect<Option.Option<EventLogEntry>, StoreIoError>;
+    /**
+     * Append multiple upsert events if missing in a single transaction.
+     */
+    readonly appendUpsertsIfMissing: (
+      store: StoreRef,
+      events: ReadonlyArray<PostUpsert>
+    ) => Effect.Effect<ReadonlyArray<Option.Option<EventLogEntry>>, StoreIoError>;
 
     /**
      * Append a delete event to the store, removing the post.
@@ -125,6 +139,26 @@ export class StoreCommitter extends Context.Tag("@skygent/StoreCommitter")<
             .pipe(Effect.mapError(toStoreIoError(store.root)))
       );
 
+      const appendUpserts = Effect.fn("StoreCommitter.appendUpserts")(
+        (store: StoreRef, events: ReadonlyArray<PostUpsert>) => {
+          if (events.length === 0) {
+            return Effect.succeed([] as ReadonlyArray<EventLogEntry>);
+          }
+          return storeDb
+            .withClient(store, (client) =>
+              client.withTransaction(
+                Effect.forEach(events, (event) =>
+                  Effect.gen(function* () {
+                    yield* upsertPost(client, event.post);
+                    return yield* writer.appendWithClient(client, event);
+                  })
+                )
+              )
+            )
+            .pipe(Effect.mapError(toStoreIoError(store.root)));
+        }
+      );
+
       const appendUpsertIfMissing = Effect.fn(
         "StoreCommitter.appendUpsertIfMissing"
       )((store: StoreRef, event: PostUpsert) =>
@@ -144,6 +178,30 @@ export class StoreCommitter extends Context.Tag("@skygent/StoreCommitter")<
           .pipe(Effect.mapError(toStoreIoError(store.root)))
       );
 
+      const appendUpsertsIfMissing = Effect.fn(
+        "StoreCommitter.appendUpsertsIfMissing"
+      )((store: StoreRef, events: ReadonlyArray<PostUpsert>) => {
+        if (events.length === 0) {
+          return Effect.succeed([] as ReadonlyArray<Option.Option<EventLogEntry>>);
+        }
+        return storeDb
+          .withClient(store, (client) =>
+            client.withTransaction(
+              Effect.forEach(events, (event) =>
+                Effect.gen(function* () {
+                  const inserted = yield* insertPostIfMissing(client, event.post);
+                  if (!inserted) {
+                    return Option.none<EventLogEntry>();
+                  }
+                  const entry = yield* writer.appendWithClient(client, event);
+                  return Option.some(entry);
+                })
+              )
+            )
+          )
+          .pipe(Effect.mapError(toStoreIoError(store.root)));
+      });
+
       const appendDelete = Effect.fn("StoreCommitter.appendDelete")(
         (store: StoreRef, event: PostDelete) =>
           storeDb
@@ -160,7 +218,9 @@ export class StoreCommitter extends Context.Tag("@skygent/StoreCommitter")<
 
       return StoreCommitter.of({
         appendUpsert,
+        appendUpserts,
         appendUpsertIfMissing,
+        appendUpsertsIfMissing,
         appendDelete
       });
     })

package/src/services/store-manager.ts

@@ -63,7 +63,7 @@ import * as MigratorFileSystem from "@effect/sql/Migrator/FileSystem";
 import * as SqlClient from "@effect/sql/SqlClient";
 import * as SqlSchema from "@effect/sql/SqlSchema";
 import { SqliteClient } from "@effect/sql-sqlite-bun";
-import { StoreIoError } from "../domain/errors.js";
+import { StoreAlreadyExists, StoreIoError, StoreNotFound } from "../domain/errors.js";
 import { StoreConfig, StoreMetadata, StoreRef } from "../domain/store.js";
 import { StoreName, StorePath } from "../domain/primitives.js";
 import { AppConfigService } from "./app-config.js";
@@ -188,6 +188,23 @@ export class StoreManager extends Context.Tag("@skygent/StoreManager")<
     readonly deleteStore: (
       name: StoreName
     ) => Effect.Effect<void, StoreIoError>;
+
+    /**
+     * Renames a store in the catalog.
+     *
+     * This updates the store name and root path while preserving creation time.
+     *
+     * @param from - Existing store name
+     * @param to - New store name
+     * @returns Effect resolving to the updated StoreRef
+     * @throws {StoreNotFound} If the source store does not exist
+     * @throws {StoreAlreadyExists} If the target store already exists
+     * @throws {StoreIoError} When database operations fail
+     */
+    readonly renameStore: (
+      from: StoreName,
+      to: StoreName
+    ) => Effect.Effect<StoreRef, StoreNotFound | StoreAlreadyExists | StoreIoError>;
   }
 >() {
   /**
@@ -267,6 +284,21 @@ export class StoreManager extends Context.Tag("@skygent/StoreManager")<
           client`DELETE FROM stores WHERE name = ${name}`
       });
 
+      const renameStoreSql = SqlSchema.void({
+        Request: Schema.Struct({
+          oldName: StoreName,
+          newName: StoreName,
+          root: StorePath,
+          updatedAt: Schema.String
+        }),
+        execute: ({ oldName, newName, root, updatedAt }) =>
+          client`UPDATE stores
+            SET name = ${newName},
+                root = ${root},
+                updated_at = ${updatedAt}
+            WHERE name = ${oldName}`
+      });
+
       const createStore = Effect.fn("StoreManager.createStore")(
         (name: StoreName, config: StoreConfig) =>
           decodeStorePath(storeRootKey(name)).pipe(
@@ -337,6 +369,34 @@ export class StoreManager extends Context.Tag("@skygent/StoreManager")<
         );
       });
 
+      const renameStore = Effect.fn("StoreManager.renameStore")(
+        (from: StoreName, to: StoreName) =>
+          Effect.gen(function* () {
+            const newRoot = yield* decodeStorePath(storeRootKey(to));
+            const existing = yield* findStore(from).pipe(
+              Effect.mapError(toStoreIoError(manifestPath))
+            );
+            if (existing.length === 0) {
+              return yield* StoreNotFound.make({ name: from });
+            }
+            const conflict = yield* findStore(to).pipe(
+              Effect.mapError(toStoreIoError(manifestPath))
+            );
+            if (conflict.length > 0) {
+              return yield* StoreAlreadyExists.make({ name: to });
+            }
+            const nowMillis = yield* Clock.currentTimeMillis;
+            const now = new Date(nowMillis).toISOString();
+            yield* renameStoreSql({
+              oldName: from,
+              newName: to,
+              root: newRoot,
+              updatedAt: now
+            }).pipe(Effect.mapError(toStoreIoError(manifestPath)));
+            return StoreRef.make({ name: to, root: newRoot });
+          })
+      );
+
       const listStores = Effect.fn("StoreManager.listStores")(() =>
         Effect.gen(function* () {
           const rows = yield* listStoresSql(undefined);
@@ -352,7 +412,14 @@ export class StoreManager extends Context.Tag("@skygent/StoreManager")<
         }).pipe(Effect.mapError(toStoreIoError(manifestPath)))
       );
 
-      return StoreManager.of({ createStore, getStore, listStores, getConfig, deleteStore });
+      return StoreManager.of({
+        createStore,
+        getStore,
+        listStores,
+        getConfig,
+        deleteStore,
+        renameStore
+      });
     })
   ).pipe(Layer.provide(Reactivity.layer));
 }