@mepuka/skygent 0.2.0 → 0.3.1

package/src/cli/store.ts

@@ -14,12 +14,14 @@ import { StoreCleaner } from "../services/store-cleaner.js";
 import { LineageStore } from "../services/lineage-store.js";
 import { CliInputError } from "./errors.js";
 import { OutputManager } from "../services/output-manager.js";
-import { formatStoreConfigParseError } from "./store-errors.js";
+import { formatStoreConfigHelp, formatStoreConfigParseError } from "./store-errors.js";
 import { formatFilterExpr } from "../domain/filter-describe.js";
 import { CliPreferences } from "./preferences.js";
 import { StoreStats } from "../services/store-stats.js";
 import { withExamples } from "./help.js";
 import { resolveOutputFormat, treeTableJsonFormats } from "./output-format.js";
+import { StoreRenamer } from "../services/store-renamer.js";
+import { PositiveInt } from "./option-schemas.js";
 import {
   buildStoreTreeData,
   renderStoreTree,
@@ -33,6 +35,14 @@ const storeNameArg = Args.text({ name: "name" }).pipe(
   Args.withSchema(StoreName),
   Args.withDescription("Store name")
 );
+const storeRenameFromArg = Args.text({ name: "from" }).pipe(
+  Args.withSchema(StoreName),
+  Args.withDescription("Existing store name")
+);
+const storeRenameToArg = Args.text({ name: "to" }).pipe(
+  Args.withSchema(StoreName),
+  Args.withDescription("New store name")
+);
 const storeNameOption = Options.text("store").pipe(
   Options.withSchema(StoreName),
   Options.withDescription("Store name")
@@ -53,6 +63,7 @@ const treeAnsiOption = Options.boolean("ansi").pipe(
   Options.withDescription("Enable ANSI color output for tree format")
 );
 const treeWidthOption = Options.integer("width").pipe(
+  Options.withSchema(PositiveInt),
   Options.withDescription("Line width for tree rendering (enables wrapping)"),
   Options.optional
 );
@@ -239,6 +250,10 @@ export const storeDelete = Command.make(
       const cleaner = yield* StoreCleaner;
       const result = yield* cleaner.deleteStore(name);
       if (!result.deleted) {
+        if (result.reason === "missing") {
+          yield* writeJson(result);
+          return;
+        }
         return yield* CliInputError.make({
           message: `Store "${name}" was not deleted.`,
           cause: result
@@ -254,6 +269,27 @@ export const storeDelete = Command.make(
   )
 );
 
+export const storeRename = Command.make(
+  "rename",
+  { from: storeRenameFromArg, to: storeRenameToArg },
+  ({ from, to }) =>
+    Effect.gen(function* () {
+      if (from === to) {
+        return yield* CliInputError.make({
+          message: "Old and new store names must be different.",
+          cause: { from, to }
+        });
+      }
+      const renamer = yield* StoreRenamer;
+      const result = yield* renamer.rename(from, to);
+      yield* writeJson(result);
+    })
+).pipe(
+  Command.withDescription(
+    withExamples("Rename a store", ["skygent store rename old-name new-name"])
+  )
+);
+
 export const storeMaterialize = Command.make(
   "materialize",
   { name: storeNameArg, filter: filterNameOption },
@@ -267,7 +303,9 @@ export const storeMaterialize = Command.make(
 
       if (config.filters.length === 0) {
         return yield* CliInputError.make({
-          message: `Store "${name}" has no configured filters to materialize. Update the store config to add filters.`,
+          message: formatStoreConfigHelp(
+            `Store "${name}" has no configured filters to materialize. Add filters to the store config.`
+          ),
           cause: { store: name }
         });
       }
@@ -378,6 +416,7 @@ export const storeCommand = Command.make("store", {}).pipe(
     storeCreate,
     storeList,
     storeShow,
+    storeRename,
     storeDelete,
     storeMaterialize,
     storeStats,

package/src/cli/stream-merge.ts

@@ -0,0 +1,105 @@
+import { Chunk, Effect, Option, Order, Stream } from "effect";
+
+export const mergeOrderedStreams = <A, E, R>(
+  streams: ReadonlyArray<Stream.Stream<A, E, R>>,
+  order: Order.Order<A>
+): Stream.Stream<A, E, R> => {
+  if (streams.length === 0) {
+    return Stream.empty;
+  }
+
+  return Stream.unwrapScoped(
+    Effect.gen(function* () {
+      const pulls = yield* Effect.forEach(streams, (stream) => Stream.toPull(stream), {
+        discard: false
+      });
+
+      const buffers: Array<ReadonlyArray<A>> = pulls.map(() => []);
+      const indices: number[] = pulls.map(() => 0);
+      const heads: Array<A | undefined> = pulls.map(() => undefined);
+      let active = pulls.length;
+
+      const pullChunk = (index: number) =>
+        pulls[index]!.pipe(
+          Effect.map(Option.some),
+          Effect.catchAll((cause) =>
+            Option.match(cause, {
+              onNone: () => Effect.succeed(Option.none()),
+              onSome: (error) => Effect.fail(error)
+            })
+          )
+        );
+
+      const nextValue = (index: number): Effect.Effect<Option.Option<A>, E, R> =>
+        Effect.gen(function* () {
+          while (true) {
+            const buffer = buffers[index] ?? [];
+            const position = indices[index] ?? 0;
+            if (position < buffer.length) {
+              const value = buffer[position]!;
+              indices[index] = position + 1;
+              return Option.some(value);
+            }
+
+            const nextChunkOption = yield* pullChunk(index);
+            if (Option.isNone(nextChunkOption)) {
+              return Option.none<A>();
+            }
+            const nextChunk = Chunk.toReadonlyArray(nextChunkOption.value);
+            if (nextChunk.length === 0) {
+              continue;
+            }
+            buffers[index] = nextChunk;
+            indices[index] = 1;
+            return Option.some(nextChunk[0]!);
+          }
+        });
+
+      for (let index = 0; index < pulls.length; index += 1) {
+        const next = yield* nextValue(index);
+        if (Option.isNone(next)) {
+          active -= 1;
+          heads[index] = undefined;
+        } else {
+          heads[index] = next.value;
+        }
+      }
+
+      const pull: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R> =
+        Effect.gen(function* () {
+          if (active === 0) {
+            return yield* Effect.fail(Option.none<E>());
+          }
+
+          let selectedIndex = -1;
+          let selectedValue: A | undefined;
+          for (let index = 0; index < heads.length; index += 1) {
+            const value = heads[index];
+            if (value === undefined) continue;
+            if (selectedIndex < 0 || order(value, selectedValue as A) < 0) {
+              selectedIndex = index;
+              selectedValue = value;
+            }
+          }
+
+          if (selectedIndex < 0 || selectedValue === undefined) {
+            return yield* Effect.fail(Option.none<E>());
+          }
+
+          const next = yield* nextValue(selectedIndex).pipe(
+            Effect.mapError(Option.some)
+          );
+          if (Option.isNone(next)) {
+            heads[selectedIndex] = undefined;
+            active -= 1;
+          } else {
+            heads[selectedIndex] = next.value;
+          }
+
+          return Chunk.of(selectedValue);
+        });
+
+      return Stream.fromPull(Effect.succeed(pull));
+    })
+  );
+};

package/src/cli/sync-factory.ts

@@ -1,14 +1,15 @@
-import { Effect, Option, Stream } from "effect";
+import { Duration, Effect, Option, Stream } from "effect";
 import { DataSource, SyncResult, WatchConfig } from "../domain/sync.js";
 import { SyncEngine } from "../services/sync-engine.js";
 import { SyncReporter } from "../services/sync-reporter.js";
 import { OutputManager } from "../services/output-manager.js";
 import { ResourceMonitor } from "../services/resource-monitor.js";
+import { StoreIndex } from "../services/store-index.js";
 import { parseFilterExpr } from "./filter-input.js";
 import { CliOutput, writeJson, writeJsonStream } from "./output.js";
 import { storeOptions } from "./store.js";
 import { logInfo, logWarn, makeSyncReporter } from "./logging.js";
-import { parseInterval } from "./interval.js";
+import { parseInterval, parseOptionalDuration } from "./interval.js";
 import type { StoreName } from "../domain/primitives.js";
 
 /** Common options shared by sync and watch API-based commands */
@@ -18,6 +19,7 @@ export interface CommonCommandInput {
   readonly filterJson: Option.Option<string>;
   readonly quiet: boolean;
   readonly refresh: boolean;
+  readonly limit?: Option.Option<number>;
 }
 
 /** Build the command body for a one-shot sync command (timeline, feed, notifications). */
@@ -32,6 +34,7 @@ export const makeSyncCommandBody = (
       const monitor = yield* ResourceMonitor;
       const output = yield* CliOutput;
       const outputManager = yield* OutputManager;
+      const index = yield* StoreIndex;
       const storeRef = yield* storeOptions.loadStoreRef(input.store);
       const storeConfig = yield* storeOptions.loadStoreConfig(input.store);
       const expr = yield* parseFilterExpr(input.filter, input.filterJson);
@@ -44,8 +47,12 @@ export const makeSyncCommandBody = (
           store: storeRef.name
         });
       }
+      const limitValue = Option.getOrUndefined(input.limit ?? Option.none());
       const result = yield* sync
-        .sync(makeDataSource(), storeRef, expr, { policy })
+        .sync(makeDataSource(), storeRef, expr, {
+          policy,
+          ...(limitValue !== undefined ? { limit: limitValue } : {})
+        })
         .pipe(
           Effect.provideService(SyncReporter, makeSyncReporter(input.quiet, monitor, output))
         );
@@ -56,13 +63,16 @@ export const makeSyncCommandBody = (
           filters: materialized.filters.map((spec) => spec.name)
         });
       }
+      const totalPosts = yield* index.count(storeRef);
       yield* logInfo("Sync complete", { source: sourceName, store: storeRef.name, ...extraLogFields });
-      yield* writeJson(result as SyncResult);
+      yield* writeJson({ ...(result as SyncResult), totalPosts });
     });
 
 /** Common options for watch API-based commands */
 export interface WatchCommandInput extends CommonCommandInput {
-  readonly interval: Option.Option<string>;
+  readonly interval: Option.Option<Duration.Duration>;
+  readonly maxCycles: Option.Option<number>;
+  readonly until: Option.Option<Duration.Duration>;
 }
 
 /** Build the command body for a watch command (timeline, feed, notifications). */
@@ -81,7 +91,8 @@ export const makeWatchCommandBody = (
       const expr = yield* parseFilterExpr(input.filter, input.filterJson);
       const basePolicy = storeConfig.syncPolicy ?? "dedupe";
       const policy = input.refresh ? "refresh" : basePolicy;
-      const parsedInterval = yield* parseInterval(input.interval);
+      const parsedInterval = parseInterval(input.interval);
+      const parsedUntil = parseOptionalDuration(input.until);
       yield* logInfo("Starting watch", { source: sourceName, store: storeRef.name, ...extraLogFields });
       if (policy === "refresh") {
         yield* logWarn("Refresh mode updates existing posts and may grow the event log.", {
@@ -89,7 +100,7 @@ export const makeWatchCommandBody = (
           store: storeRef.name
         });
       }
-      const stream = sync
+      let stream = sync
         .watch(
           WatchConfig.make({
             source: makeDataSource(),
@@ -103,5 +114,11 @@ export const makeWatchCommandBody = (
           Stream.map((event) => event.result),
           Stream.provideService(SyncReporter, makeSyncReporter(input.quiet, monitor, output))
         );
+      if (Option.isSome(input.maxCycles)) {
+        stream = stream.pipe(Stream.take(input.maxCycles.value));
+      }
+      if (Option.isSome(parsedUntil)) {
+        stream = stream.pipe(Stream.interruptWhen(Effect.sleep(parsedUntil.value)));
+      }
       yield* writeJsonStream(stream);
     });

package/src/cli/sync.ts

@@ -1,5 +1,5 @@
 import { Command, Options } from "@effect/cli";
-import { Duration, Effect, Layer, Option } from "effect";
+import { Effect, Layer, Option } from "effect";
 import { Jetstream } from "effect-jetstream";
 import { filterExprSignature } from "../domain/filter.js";
 import { DataSource, SyncResult } from "../domain/sync.js";
@@ -9,6 +9,7 @@ import { logInfo, makeSyncReporter } from "./logging.js";
 import { SyncReporter } from "../services/sync-reporter.js";
 import { ResourceMonitor } from "../services/resource-monitor.js";
 import { OutputManager } from "../services/output-manager.js";
+import { StoreIndex } from "../services/store-index.js";
 import { CliOutput, writeJson } from "./output.js";
 import { parseFilterExpr } from "./filter-input.js";
 import { withExamples } from "./help.js";
@@ -27,61 +28,44 @@ import {
   postFilterJsonOption,
   authorFilterOption,
   includePinsOption,
-  decodeActor,
   quietOption,
   refreshOption,
   strictOption,
-  maxErrorsOption,
-  parseMaxErrors,
-  parseLimit,
-  parseBoundedIntOption
+  maxErrorsOption
 } from "./shared-options.js";
+import {
+  depthOption as threadDepthOption,
+  parentHeightOption as threadParentHeightOption,
+  parseThreadDepth
+} from "./thread-options.js";
+import { DurationInput, PositiveInt } from "./option-schemas.js";
 
-const limitOption = Options.integer("limit").pipe(
+const syncLimitOption = Options.integer("limit").pipe(
+  Options.withSchema(PositiveInt),
+  Options.withDescription("Maximum number of posts to sync"),
+  Options.optional
+);
+const jetstreamLimitOption = Options.integer("limit").pipe(
+  Options.withSchema(PositiveInt),
   Options.withDescription("Maximum number of Jetstream events to process"),
   Options.optional
 );
 const durationOption = Options.text("duration").pipe(
+  Options.withSchema(DurationInput),
   Options.withDescription("Stop after a duration (e.g. \"2 minutes\")"),
   Options.optional
 );
-const depthOption = Options.integer("depth").pipe(
-  Options.withDescription("Thread reply depth to include (0-1000, default 6)"),
-  Options.optional
+const depthOption = threadDepthOption(
+  "Thread reply depth to include (0-1000, default 6)"
 );
-const parentHeightOption = Options.integer("parent-height").pipe(
-  Options.withDescription("Thread parent height to include (0-1000, default 80)"),
-  Options.optional
+const parentHeightOption = threadParentHeightOption(
+  "Thread parent height to include (0-1000, default 80)"
 );
 
-const parseDuration = (value: Option.Option<string>) =>
-  Option.match(value, {
-    onNone: () => Effect.succeed(Option.none()),
-    onSome: (raw) =>
-      Effect.try({
-        try: () => Duration.decode(raw as Duration.DurationInput),
-        catch: (cause) =>
-          CliInputError.make({
-            message: `Invalid duration: ${raw}. Use formats like \"2 minutes\".`,
-            cause
-          })
-      }).pipe(
-        Effect.flatMap((duration) =>
-          Duration.toMillis(duration) < 0
-            ? Effect.fail(
-                CliInputError.make({
-                  message: "Duration must be non-negative.",
-                  cause: duration
-                })
-              )
-            : Effect.succeed(Option.some(duration))
-        )
-      )
-  });
 
 const timelineCommand = Command.make(
   "timeline",
-  { store: storeNameOption, filter: filterOption, filterJson: filterJsonOption, quiet: quietOption, refresh: refreshOption },
+  { store: storeNameOption, filter: filterOption, filterJson: filterJsonOption, quiet: quietOption, refresh: refreshOption, limit: syncLimitOption },
   makeSyncCommandBody("timeline", () => DataSource.timeline())
 ).pipe(
   Command.withDescription(
@@ -98,7 +82,7 @@ const timelineCommand = Command.make(
 
 const feedCommand = Command.make(
   "feed",
-  { uri: feedUriArg, store: storeNameOption, filter: filterOption, filterJson: filterJsonOption, quiet: quietOption, refresh: refreshOption },
+  { uri: feedUriArg, store: storeNameOption, filter: filterOption, filterJson: filterJsonOption, quiet: quietOption, refresh: refreshOption, limit: syncLimitOption },
   ({ uri, ...rest }) => makeSyncCommandBody("feed", () => DataSource.feed(uri), { uri })(rest)
 ).pipe(
   Command.withDescription(
@@ -114,7 +98,7 @@ const feedCommand = Command.make(
 
 const listCommand = Command.make(
   "list",
-  { uri: listUriArg, store: storeNameOption, filter: filterOption, filterJson: filterJsonOption, quiet: quietOption, refresh: refreshOption },
+  { uri: listUriArg, store: storeNameOption, filter: filterOption, filterJson: filterJsonOption, quiet: quietOption, refresh: refreshOption, limit: syncLimitOption },
   ({ uri, ...rest }) => makeSyncCommandBody("list", () => DataSource.list(uri), { uri })(rest)
 ).pipe(
   Command.withDescription(
@@ -130,7 +114,7 @@ const listCommand = Command.make(
 
 const notificationsCommand = Command.make(
   "notifications",
-  { store: storeNameOption, filter: filterOption, filterJson: filterJsonOption, quiet: quietOption, refresh: refreshOption },
+  { store: storeNameOption, filter: filterOption, filterJson: filterJsonOption, quiet: quietOption, refresh: refreshOption, limit: syncLimitOption },
   makeSyncCommandBody("notifications", () => DataSource.notifications())
 ).pipe(
   Command.withDescription(
@@ -152,18 +136,18 @@ const authorCommand = Command.make(
     postFilter: postFilterOption,
     postFilterJson: postFilterJsonOption,
     quiet: quietOption,
-    refresh: refreshOption
+    refresh: refreshOption,
+    limit: syncLimitOption
   },
-  ({ actor, filter, includePins, postFilter, postFilterJson, store, quiet, refresh }) =>
+  ({ actor, filter, includePins, postFilter, postFilterJson, store, quiet, refresh, limit }) =>
     Effect.gen(function* () {
-      const resolvedActor = yield* decodeActor(actor);
       const apiFilter = Option.getOrUndefined(filter);
-      const source = DataSource.author(resolvedActor, {
+      const source = DataSource.author(actor, {
         ...(apiFilter !== undefined ? { filter: apiFilter } : {}),
         ...(includePins ? { includePins: true } : {})
       });
       const run = makeSyncCommandBody("author", () => source, {
-        actor: resolvedActor,
+        actor,
         ...(apiFilter !== undefined ? { filter: apiFilter } : {}),
         ...(includePins ? { includePins: true } : {})
       });
@@ -172,7 +156,8 @@ const authorCommand = Command.make(
         filter: postFilter,
         filterJson: postFilterJson,
         quiet,
-        refresh
+        refresh,
+        limit
       });
     })
 ).pipe(
@@ -198,19 +183,13 @@ const threadCommand = Command.make(
     filter: filterOption,
     filterJson: filterJsonOption,
     quiet: quietOption,
-    refresh: refreshOption
+    refresh: refreshOption,
+    limit: syncLimitOption
   },
-  ({ uri, depth, parentHeight, filter, filterJson, store, quiet, refresh }) =>
+  ({ uri, depth, parentHeight, filter, filterJson, store, quiet, refresh, limit }) =>
     Effect.gen(function* () {
-      const parsedDepth = yield* parseBoundedIntOption(depth, "depth", 0, 1000);
-      const parsedParentHeight = yield* parseBoundedIntOption(
-        parentHeight,
-        "parent-height",
-        0,
-        1000
-      );
-      const depthValue = Option.getOrUndefined(parsedDepth);
-      const parentHeightValue = Option.getOrUndefined(parsedParentHeight);
+      const { depth: depthValue, parentHeight: parentHeightValue } =
+        parseThreadDepth(depth, parentHeight);
       const source = DataSource.thread(uri, {
         ...(depthValue !== undefined ? { depth: depthValue } : {}),
         ...(parentHeightValue !== undefined ? { parentHeight: parentHeightValue } : {})
@@ -220,7 +199,7 @@ const threadCommand = Command.make(
         ...(depthValue !== undefined ? { depth: depthValue } : {}),
         ...(parentHeightValue !== undefined ? { parentHeight: parentHeightValue } : {})
       });
-      return yield* run({ store, filter, filterJson, quiet, refresh });
+      return yield* run({ store, filter, filterJson, quiet, refresh, limit });
     })
 ).pipe(
   Command.withDescription(
@@ -248,7 +227,7 @@ const jetstreamCommand = Command.make(
     cursor: jetstreamOptions.cursor,
     compress: jetstreamOptions.compress,
     maxMessageSize: jetstreamOptions.maxMessageSize,
-    limit: limitOption,
+    limit: jetstreamLimitOption,
     duration: durationOption,
     strict: strictOption,
     maxErrors: maxErrorsOption
@@ -273,6 +252,7 @@ const jetstreamCommand = Command.make(
       const monitor = yield* ResourceMonitor;
       const output = yield* CliOutput;
       const outputManager = yield* OutputManager;
+      const index = yield* StoreIndex;
       const storeRef = yield* storeOptions.loadStoreRef(store);
       const expr = yield* parseFilterExpr(filter, filterJson);
       const filterHash = filterExprSignature(expr);
@@ -288,10 +268,8 @@ const jetstreamCommand = Command.make(
         storeRef,
         filterHash
       );
-      const parsedLimit = yield* parseLimit(limit);
-      const parsedDuration = yield* parseDuration(duration);
-      const parsedMaxErrors = yield* parseMaxErrors(maxErrors);
-      if (Option.isNone(parsedLimit) && Option.isNone(parsedDuration)) {
+      const parsedDuration = duration;
+      if (Option.isNone(limit) && Option.isNone(parsedDuration)) {
         return yield* CliInputError.make({
           message:
             "Jetstream sync requires --limit or --duration. Use watch jetstream for continuous streaming.",
@@ -307,9 +285,9 @@ const jetstreamCommand = Command.make(
       });
       const result = yield* Effect.gen(function* () {
         const engine = yield* JetstreamSyncEngine;
-        const limitValue = Option.getOrUndefined(parsedLimit);
+        const limitValue = Option.getOrUndefined(limit);
         const durationValue = Option.getOrUndefined(parsedDuration);
-        const maxErrorsValue = Option.getOrUndefined(parsedMaxErrors);
+        const maxErrorsValue = Option.getOrUndefined(maxErrors);
         return yield* engine.sync({
           source: selection.source,
           store: storeRef,
@@ -332,8 +310,9 @@ const jetstreamCommand = Command.make(
           filters: materialized.filters.map((spec) => spec.name)
         });
       }
+      const totalPosts = yield* index.count(storeRef);
       yield* logInfo("Sync complete", { source: "jetstream", store: storeRef.name });
-      yield* writeJson(result as SyncResult);
+      yield* writeJson({ ...(result as SyncResult), totalPosts });
     })
 ).pipe(
   Command.withDescription(

package/src/cli/thread-options.ts

@@ -0,0 +1,25 @@
+import { Options } from "@effect/cli";
+import { Option } from "effect";
+import { boundedInt } from "./option-schemas.js";
+
+export const depthOption = (description: string) =>
+  Options.integer("depth").pipe(
+    Options.withSchema(boundedInt(0, 1000)),
+    Options.withDescription(description),
+    Options.optional
+  );
+
+export const parentHeightOption = (description: string) =>
+  Options.integer("parent-height").pipe(
+    Options.withSchema(boundedInt(0, 1000)),
+    Options.withDescription(description),
+    Options.optional
+  );
+
+export const parseThreadDepth = (
+  depth: Option.Option<number>,
+  parentHeight: Option.Option<number>
+) => ({
+  depth: Option.getOrUndefined(depth),
+  parentHeight: Option.getOrUndefined(parentHeight)
+});