@mepuka/skygent 0.2.0 → 0.3.0

package/src/cli/sync-factory.ts

@@ -4,11 +4,13 @@ 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 { CliInputError } from "./errors.js";
 import type { StoreName } from "../domain/primitives.js";
 
 /** Common options shared by sync and watch API-based commands */
@@ -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);
@@ -56,13 +59,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 maxCycles: Option.Option<number>;
+  readonly until: Option.Option<string>;
 }
 
 /** Build the command body for a watch command (timeline, feed, notifications). */
@@ -82,6 +88,19 @@ export const makeWatchCommandBody = (
       const basePolicy = storeConfig.syncPolicy ?? "dedupe";
       const policy = input.refresh ? "refresh" : basePolicy;
       const parsedInterval = yield* parseInterval(input.interval);
+      const parsedUntil = yield* parseOptionalDuration(input.until);
+      const parsedMaxCycles = yield* Option.match(input.maxCycles, {
+        onNone: () => Effect.succeed(Option.none<number>()),
+        onSome: (value) =>
+          value <= 0
+            ? Effect.fail(
+                CliInputError.make({
+                  message: "--max-cycles must be a positive integer.",
+                  cause: { maxCycles: value }
+                })
+              )
+            : Effect.succeed(Option.some(value))
+      });
       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 +108,7 @@ export const makeWatchCommandBody = (
           store: storeRef.name
         });
       }
-      const stream = sync
+      let stream = sync
         .watch(
           WatchConfig.make({
             source: makeDataSource(),
@@ -103,5 +122,11 @@ export const makeWatchCommandBody = (
           Stream.map((event) => event.result),
           Stream.provideService(SyncReporter, makeSyncReporter(input.quiet, monitor, output))
         );
+      if (Option.isSome(parsedMaxCycles)) {
+        stream = stream.pipe(Stream.take(parsedMaxCycles.value));
+      }
+      if (Option.isSome(parsedUntil)) {
+        stream = stream.pipe(Stream.interruptWhen(Effect.sleep(parsedUntil.value)));
+      }
       yield* writeJsonStream(stream);
     });

package/src/cli/sync.ts

@@ -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";
@@ -33,9 +34,13 @@ import {
   strictOption,
   maxErrorsOption,
   parseMaxErrors,
-  parseLimit,
-  parseBoundedIntOption
+  parseLimit
 } from "./shared-options.js";
+import {
+  depthOption as threadDepthOption,
+  parentHeightOption as threadParentHeightOption,
+  parseThreadDepth
+} from "./thread-options.js";
 
 const limitOption = Options.integer("limit").pipe(
   Options.withDescription("Maximum number of Jetstream events to process"),
@@ -45,13 +50,11 @@ const durationOption = Options.text("duration").pipe(
   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>) =>
@@ -202,15 +205,8 @@ const threadCommand = Command.make(
   },
   ({ uri, depth, parentHeight, filter, filterJson, store, quiet, refresh }) =>
     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 } =
+        yield* parseThreadDepth(depth, parentHeight);
       const source = DataSource.thread(uri, {
         ...(depthValue !== undefined ? { depth: depthValue } : {}),
         ...(parentHeightValue !== undefined ? { parentHeight: parentHeightValue } : {})
@@ -273,6 +269,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);
@@ -332,8 +329,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,33 @@
+import { Options } from "@effect/cli";
+import { Effect, Option } from "effect";
+import { parseBoundedIntOption } from "./shared-options.js";
+
+export const depthOption = (description: string) =>
+  Options.integer("depth").pipe(
+    Options.withDescription(description),
+    Options.optional
+  );
+
+export const parentHeightOption = (description: string) =>
+  Options.integer("parent-height").pipe(
+    Options.withDescription(description),
+    Options.optional
+  );
+
+export const parseThreadDepth = (
+  depth: Option.Option<number>,
+  parentHeight: Option.Option<number>
+) =>
+  Effect.gen(function* () {
+    const parsedDepth = yield* parseBoundedIntOption(depth, "depth", 0, 1000);
+    const parsedParentHeight = yield* parseBoundedIntOption(
+      parentHeight,
+      "parent-height",
+      0,
+      1000
+    );
+    return {
+      depth: Option.getOrUndefined(parsedDepth),
+      parentHeight: Option.getOrUndefined(parsedParentHeight)
+    };
+  });

package/src/cli/time.ts

@@ -0,0 +1,171 @@
+import { Duration, Effect, Schema } from "effect";
+import { Timestamp } from "../domain/primitives.js";
+import { CliInputError } from "./errors.js";
+
+export type TimeParseError = (message: string, cause?: unknown) => CliInputError;
+
+type TimeParseOptions = {
+  readonly label?: string;
+  readonly onError?: TimeParseError;
+};
+
+const defaultError: TimeParseError = (message, cause) =>
+  CliInputError.make({ message, cause });
+
+const compactDurationPattern = /^(-?\d+(?:\.\d+)?)(ms|s|m|h|d|w)$/i;
+const compactDurationUnits: Record<string, number> = {
+  ms: 1,
+  s: 1000,
+  m: 60_000,
+  h: 3_600_000,
+  d: 86_400_000,
+  w: 604_800_000
+};
+
+const parseCompactDurationMillis = (raw: string): number | undefined => {
+  const match = raw.match(compactDurationPattern);
+  if (!match) {
+    return undefined;
+  }
+  const value = Number.parseFloat(match[1] ?? "");
+  const unit = (match[2] ?? "").toLowerCase();
+  const multiplier = compactDurationUnits[unit];
+  if (!Number.isFinite(value) || multiplier === undefined) {
+    return Number.NaN;
+  }
+  return value * multiplier;
+};
+
+const toUtcStartOfDay = (date: Date) =>
+  new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+
+const parseDateOnly = (raw: string): Date | undefined => {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(raw);
+  if (!match) {
+    return undefined;
+  }
+  const year = Number.parseInt(match[1] ?? "", 10);
+  const month = Number.parseInt(match[2] ?? "", 10);
+  const day = Number.parseInt(match[3] ?? "", 10);
+  if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day)) {
+    return undefined;
+  }
+  const date = new Date(Date.UTC(year, month - 1, day));
+  if (
+    date.getUTCFullYear() !== year ||
+    date.getUTCMonth() !== month - 1 ||
+    date.getUTCDate() !== day
+  ) {
+    return undefined;
+  }
+  return date;
+};
+
+const looksLikeDate = (raw: string) => /^\d{4}-\d{2}-\d{2}/.test(raw);
+
+const hasExplicitTimezone = (raw: string) => /([zZ]|[+-]\d{2}:\d{2})$/.test(raw);
+
+const makeErrorFactory = (options?: TimeParseOptions): TimeParseError => {
+  const base = options?.onError ?? defaultError;
+  const label = options?.label;
+  if (!label) {
+    return base;
+  }
+  return (message, cause) => base(`${label}: ${message}`, cause);
+};
+
+export const parseDurationInput = (
+  raw: string,
+  options?: TimeParseOptions
+): Effect.Effect<Duration.Duration, CliInputError> =>
+  Effect.suspend(() => {
+    const onError = makeErrorFactory(options);
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+      return Effect.fail(onError("Duration cannot be empty."));
+    }
+
+    const compactMillis = parseCompactDurationMillis(trimmed);
+    if (compactMillis !== undefined) {
+      if (!Number.isFinite(compactMillis)) {
+        return Effect.fail(onError("Duration must be a finite number."));
+      }
+      if (compactMillis < 0) {
+        return Effect.fail(onError("Duration must be non-negative."));
+      }
+      return Effect.succeed(Duration.millis(compactMillis));
+    }
+
+    return Effect.try({
+      try: () => Duration.decode(trimmed as Duration.DurationInput),
+      catch: (cause) =>
+        onError(
+          `Invalid duration "${raw}". Use formats like "30 seconds", "500 millis", or "1.5h".`,
+          cause
+        )
+    }).pipe(
+      Effect.flatMap((duration) => {
+        if (!Duration.isFinite(duration)) {
+          return Effect.fail(onError("Duration must be finite."));
+        }
+        if (Duration.toMillis(duration) < 0) {
+          return Effect.fail(onError("Duration must be non-negative."));
+        }
+        return Effect.succeed(duration);
+      })
+    );
+  });
+
+export const parseTimeInput = (
+  raw: string,
+  now: Date,
+  options?: TimeParseOptions
+): Effect.Effect<Date, CliInputError> =>
+  Effect.suspend(() => {
+    const onError = makeErrorFactory(options);
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+      return Effect.fail(onError("Time value cannot be empty."));
+    }
+
+    const lower = trimmed.toLowerCase();
+    if (lower === "now") {
+      return Effect.succeed(new Date(now.getTime()));
+    }
+    if (lower === "today") {
+      return Effect.succeed(toUtcStartOfDay(now));
+    }
+    if (lower === "yesterday") {
+      return Effect.succeed(new Date(toUtcStartOfDay(now).getTime() - 86_400_000));
+    }
+
+    const dateOnly = parseDateOnly(trimmed);
+    if (dateOnly) {
+      return Effect.succeed(dateOnly);
+    }
+
+    if (looksLikeDate(trimmed)) {
+      if (/[Tt]/.test(trimmed) && !hasExplicitTimezone(trimmed)) {
+        return Effect.fail(
+          onError(
+            "Timestamp must include a timezone (e.g. 2026-01-01T00:00:00Z)."
+          )
+        );
+      }
+      return Schema.decodeUnknown(Timestamp)(trimmed).pipe(
+        Effect.mapError((cause) =>
+          onError(
+            `Invalid timestamp "${raw}". Expected ISO 8601 with timezone (e.g. 2026-01-01T00:00:00Z).`,
+            cause
+          )
+        )
+      );
+    }
+
+    return parseDurationInput(trimmed, options).pipe(
+      Effect.map((duration) => {
+        const millis = Duration.toMillis(duration);
+        return new Date(now.getTime() - millis);
+      })
+    );
+  });

package/src/cli/view-thread.ts

@@ -16,7 +16,11 @@ import { storeOptions } from "./store.js";
 import { withExamples } from "./help.js";
 import { CliInputError } from "./errors.js";
 import { formatSchemaError } from "./shared.js";
-import { parseBoundedIntOption } from "./shared-options.js";
+import {
+  depthOption as threadDepthOption,
+  parentHeightOption as threadParentHeightOption,
+  parseThreadDepth
+} from "./thread-options.js";
 import { textJsonFormats } from "./output-format.js";
 
 const uriArg = Args.text({ name: "uri" }).pipe(
@@ -47,14 +51,9 @@ const formatOption = Options.choice("format", textJsonFormats).pipe(
   Options.optional
 );
 
-const depthOption = Options.integer("depth").pipe(
-  Options.withDescription("Reply depth (API only, default: 6)"),
-  Options.optional
-);
-
-const parentHeightOption = Options.integer("parent-height").pipe(
-  Options.withDescription("Parent height (API only, default: 80)"),
-  Options.optional
+const depthOption = threadDepthOption("Reply depth (API only, default: 6)");
+const parentHeightOption = threadParentHeightOption(
+  "Parent height (API only, default: 80)"
 );
 
 export const threadCommand = Command.make(
@@ -73,15 +72,10 @@ export const threadCommand = Command.make(
     Effect.gen(function* () {
       const outputFormat = Option.getOrElse(format, () => "text" as const);
       const w = Option.getOrUndefined(width);
-      const parsedDepth = yield* parseBoundedIntOption(depth, "depth", 0, 1000);
-      const parsedParentHeight = yield* parseBoundedIntOption(
-        parentHeight,
-        "parent-height",
-        0,
-        1000
-      );
-      const d = Option.getOrElse(parsedDepth, () => 6);
-      const ph = Option.getOrElse(parsedParentHeight, () => 80);
+      const { depth: depthValue, parentHeight: parentHeightValue } =
+        yield* parseThreadDepth(depth, parentHeight);
+      const d = depthValue ?? 6;
+      const ph = parentHeightValue ?? 80;
 
       let posts: ReadonlyArray<Post>;
 

package/src/cli/watch.ts

@@ -13,6 +13,8 @@ import { ResourceMonitor } from "../services/resource-monitor.js";
 import { withExamples } from "./help.js";
 import { buildJetstreamSelection, jetstreamOptions } from "./jetstream.js";
 import { makeWatchCommandBody } from "./sync-factory.js";
+import { parseOptionalDuration } from "./interval.js";
+import { CliInputError } from "./errors.js";
 import {
   feedUriArg,
   listUriArg,
@@ -30,9 +32,13 @@ import {
   refreshOption,
   strictOption,
   maxErrorsOption,
-  parseMaxErrors,
-  parseBoundedIntOption
+  parseMaxErrors
 } from "./shared-options.js";
+import {
+  depthOption as threadDepthOption,
+  parentHeightOption as threadParentHeightOption,
+  parseThreadDepth
+} from "./thread-options.js";
 
 const intervalOption = Options.text("interval").pipe(
   Options.withDescription(
@@ -40,14 +46,20 @@ const intervalOption = Options.text("interval").pipe(
   ),
   Options.optional
 );
-const depthOption = Options.integer("depth").pipe(
-  Options.withDescription("Thread reply depth to include (0-1000, default 6)"),
+const maxCyclesOption = Options.integer("max-cycles").pipe(
+  Options.withDescription("Stop after N watch cycles"),
   Options.optional
 );
-const parentHeightOption = Options.integer("parent-height").pipe(
-  Options.withDescription("Thread parent height to include (0-1000, default 80)"),
+const untilOption = Options.text("until").pipe(
+  Options.withDescription("Stop after a duration (e.g. \"10 minutes\")"),
   Options.optional
 );
+const depthOption = threadDepthOption(
+  "Thread reply depth to include (0-1000, default 6)"
+);
+const parentHeightOption = threadParentHeightOption(
+  "Thread parent height to include (0-1000, default 80)"
+);
 
 const timelineCommand = Command.make(
   "timeline",
@@ -56,6 +68,8 @@ const timelineCommand = Command.make(
     filter: filterOption,
     filterJson: filterJsonOption,
     interval: intervalOption,
+    maxCycles: maxCyclesOption,
+    until: untilOption,
     quiet: quietOption,
     refresh: refreshOption
   },
@@ -81,6 +95,8 @@ const feedCommand = Command.make(
     filter: filterOption,
     filterJson: filterJsonOption,
     interval: intervalOption,
+    maxCycles: maxCyclesOption,
+    until: untilOption,
     quiet: quietOption,
     refresh: refreshOption
   },
@@ -105,6 +121,8 @@ const listCommand = Command.make(
     filter: filterOption,
     filterJson: filterJsonOption,
     interval: intervalOption,
+    maxCycles: maxCyclesOption,
+    until: untilOption,
     quiet: quietOption,
     refresh: refreshOption
   },
@@ -128,6 +146,8 @@ const notificationsCommand = Command.make(
     filter: filterOption,
     filterJson: filterJsonOption,
     interval: intervalOption,
+    maxCycles: maxCyclesOption,
+    until: untilOption,
     quiet: quietOption,
     refresh: refreshOption
   },
@@ -152,10 +172,12 @@ const authorCommand = Command.make(
     postFilter: postFilterOption,
     postFilterJson: postFilterJsonOption,
     interval: intervalOption,
+    maxCycles: maxCyclesOption,
+    until: untilOption,
     quiet: quietOption,
     refresh: refreshOption
   },
-  ({ actor, filter, includePins, postFilter, postFilterJson, interval, store, quiet, refresh }) =>
+  ({ actor, filter, includePins, postFilter, postFilterJson, interval, maxCycles, until, store, quiet, refresh }) =>
     Effect.gen(function* () {
       const resolvedActor = yield* decodeActor(actor);
       const apiFilter = Option.getOrUndefined(filter);
@@ -173,6 +195,8 @@ const authorCommand = Command.make(
         filter: postFilter,
         filterJson: postFilterJson,
         interval,
+        maxCycles,
+        until,
         quiet,
         refresh
       });
@@ -200,20 +224,15 @@ const threadCommand = Command.make(
     filter: filterOption,
     filterJson: filterJsonOption,
     interval: intervalOption,
+    maxCycles: maxCyclesOption,
+    until: untilOption,
     quiet: quietOption,
     refresh: refreshOption
   },
-  ({ uri, depth, parentHeight, filter, filterJson, interval, store, quiet, refresh }) =>
+  ({ uri, depth, parentHeight, filter, filterJson, interval, maxCycles, until, store, quiet, refresh }) =>
     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 } =
+        yield* parseThreadDepth(depth, parentHeight);
       const source = DataSource.thread(uri, {
         ...(depthValue !== undefined ? { depth: depthValue } : {}),
         ...(parentHeightValue !== undefined ? { parentHeight: parentHeightValue } : {})
@@ -223,7 +242,7 @@ const threadCommand = Command.make(
         ...(depthValue !== undefined ? { depth: depthValue } : {}),
         ...(parentHeightValue !== undefined ? { parentHeight: parentHeightValue } : {})
       });
-      return yield* run({ store, filter, filterJson, interval, quiet, refresh });
+      return yield* run({ store, filter, filterJson, interval, maxCycles, until, quiet, refresh });
     })
 ).pipe(
   Command.withDescription(
@@ -251,6 +270,8 @@ const jetstreamCommand = Command.make(
     cursor: jetstreamOptions.cursor,
     compress: jetstreamOptions.compress,
     maxMessageSize: jetstreamOptions.maxMessageSize,
+    maxCycles: maxCyclesOption,
+    until: untilOption,
     strict: strictOption,
     maxErrors: maxErrorsOption
   },
@@ -265,6 +286,8 @@ const jetstreamCommand = Command.make(
     cursor,
     compress,
     maxMessageSize,
+    maxCycles,
+    until,
     strict,
     maxErrors
   }) =>
@@ -287,6 +310,19 @@ const jetstreamCommand = Command.make(
         filterHash
       );
       const parsedMaxErrors = yield* parseMaxErrors(maxErrors);
+      const parsedUntil = yield* parseOptionalDuration(until);
+      const parsedMaxCycles = yield* Option.match(maxCycles, {
+        onNone: () => Effect.succeed(Option.none<number>()),
+        onSome: (value) =>
+          value <= 0
+            ? Effect.fail(
+                CliInputError.make({
+                  message: "--max-cycles must be a positive integer.",
+                  cause: { maxCycles: value }
+                })
+              )
+            : Effect.succeed(Option.some(value))
+      });
       const engineLayer = JetstreamSyncEngine.layer.pipe(
         Layer.provideMerge(Jetstream.live(selection.config))
       );
@@ -310,7 +346,13 @@ const jetstreamCommand = Command.make(
             makeSyncReporter(quiet, monitor, output)
           )
         );
-        return yield* writeJsonStream(outputStream);
+        const limited = Option.isSome(parsedMaxCycles)
+          ? outputStream.pipe(Stream.take(parsedMaxCycles.value))
+          : outputStream;
+        const timed = Option.isSome(parsedUntil)
+          ? limited.pipe(Stream.interruptWhen(Effect.sleep(parsedUntil.value)))
+          : limited;
+        return yield* writeJsonStream(timed);
       }).pipe(Effect.provide(engineLayer));
     })
 ).pipe(

package/src/domain/errors.ts

@@ -42,6 +42,11 @@ export class StoreNotFound extends Schema.TaggedError<StoreNotFound>()(
   { name: StoreName }
 ) {}
 
+export class StoreAlreadyExists extends Schema.TaggedError<StoreAlreadyExists>()(
+  "StoreAlreadyExists",
+  { name: StoreName }
+) {}
+
 export class StoreIoError extends Schema.TaggedError<StoreIoError>()(
   "StoreIoError",
   { path: StorePath, cause: Schema.Unknown }
@@ -68,4 +73,4 @@ export class FilterLibraryError extends Schema.TaggedError<FilterLibraryError>()
   }
 ) {}
 
-export type StoreError = StoreNotFound | StoreIoError | StoreIndexError;
+export type StoreError = StoreNotFound | StoreAlreadyExists | StoreIoError | StoreIndexError;

package/src/domain/format.ts

@@ -2,6 +2,7 @@ import { Post } from "./post.js";
 import { displayWidth, padEndDisplay } from "./text-width.js";
 
 const headers = ["Created At", "Author", "Text", "URI"];
+const headersWithStore = ["Store", ...headers];
 const textLimit = 80;
 
 export const normalizeWhitespace = (text: string) =>
@@ -41,6 +42,16 @@ const postToMarkdownRow = (post: Post) => [
   post.uri.replace(/\|/g, "\\|")
 ];
 
+const storePostToRow = (entry: { readonly store: string; readonly post: Post }) => [
+  entry.store,
+  ...postToRow(entry.post)
+];
+
+const storePostToMarkdownRow = (entry: { readonly store: string; readonly post: Post }) => [
+  entry.store,
+  ...postToMarkdownRow(entry.post)
+];
+
 const renderTable = (
   head: ReadonlyArray<string>,
   rows: ReadonlyArray<ReadonlyArray<string>>
@@ -89,3 +100,13 @@ export const renderPostsTable = (posts: ReadonlyArray<Post>) =>
 
 export const renderPostsMarkdown = (posts: ReadonlyArray<Post>) =>
   renderMarkdownTable(headers, posts.map(postToMarkdownRow));
+
+export const renderStorePostsTable = (
+  entries: ReadonlyArray<{ readonly store: string; readonly post: Post }>
+) =>
+  renderTable(headersWithStore, entries.map(storePostToRow));
+
+export const renderStorePostsMarkdown = (
+  entries: ReadonlyArray<{ readonly store: string; readonly post: Post }>
+) =>
+  renderMarkdownTable(headersWithStore, entries.map(storePostToMarkdownRow));

package/src/domain/order.ts

@@ -0,0 +1,24 @@
+import { Order } from "effect";
+import type { Post } from "./post.js";
+import type { StoreRef } from "./store.js";
+
+export const LocaleStringOrder = Order.make<string>((left, right) => {
+  const result = left.localeCompare(right);
+  if (result < 0) return -1;
+  if (result > 0) return 1;
+  return 0;
+});
+
+export const PostOrder = Order.mapInput(
+  Order.tuple(Order.Date, LocaleStringOrder),
+  (post: Post) => [post.createdAt, post.uri] as const
+);
+
+export const StorePostOrder = Order.mapInput(
+  Order.tuple(Order.Date, LocaleStringOrder, LocaleStringOrder),
+  (entry: { readonly post: Post; readonly store: StoreRef }) =>
+    [entry.post.createdAt, entry.post.uri, entry.store.name] as const
+);
+
+export const updatedAtOrder = <A extends { readonly updatedAt: Date }>() =>
+  Order.mapInput(Order.Date, (value: A) => value.updatedAt);