@mepuka/skygent 0.2.0 → 0.3.1

package/src/cli/interval.ts

@@ -1,35 +1,6 @@
-import { Duration, Effect, Option } from "effect";
-import { CliInputError } from "./errors.js";
+import { Duration, Option } from "effect";
 
-const parseDurationText = (value: string) =>
-  Effect.try({
-    try: () => Duration.decode(value as Duration.DurationInput),
-    catch: (cause) =>
-      CliInputError.make({
-        message: `Invalid duration: ${value}. Use formats like "30 seconds" or "500 millis".`,
-        cause
-      })
-  }).pipe(
-    Effect.flatMap((duration) =>
-      Duration.toMillis(duration) < 0
-        ? Effect.fail(
-            CliInputError.make({
-              message: "Interval must be non-negative.",
-              cause: duration
-            })
-          )
-        : Effect.succeed(duration)
-    )
-  );
+export const parseInterval = (interval: Option.Option<Duration.Duration>) =>
+  Option.getOrElse(interval, () => Duration.seconds(30));
 
-export const parseInterval = (interval: Option.Option<string>) =>
-  Option.match(interval, {
-    onSome: parseDurationText,
-    onNone: () => Effect.succeed(Duration.seconds(30))
-  });
-
-export const parseOptionalDuration = (value: Option.Option<string>) =>
-  Option.match(value, {
-    onSome: (raw) => parseDurationText(raw).pipe(Effect.map(Option.some)),
-    onNone: () => Effect.succeed(Option.none())
-  });
+export const parseOptionalDuration = (value: Option.Option<Duration.Duration>) => value;

package/src/cli/jetstream.ts

@@ -5,6 +5,7 @@ import { DataSource } from "../domain/sync.js";
 import type { StoreRef } from "../domain/store.js";
 import { SyncCheckpointStore } from "../services/sync-checkpoint-store.js";
 import { CliInputError } from "./errors.js";
+import { PositiveInt } from "./option-schemas.js";
 
 const DEFAULT_COLLECTIONS = ["app.bsky.feed.post"];
 
@@ -31,6 +32,7 @@ export const jetstreamOptions = {
     Options.withDescription("Enable compression if supported by runtime")
   ),
   maxMessageSize: Options.integer("max-message-size").pipe(
+    Options.withSchema(PositiveInt),
     Options.withDescription("Max message size in bytes"),
     Options.optional
   )

package/src/cli/layers.ts

@@ -18,10 +18,12 @@ import { SyncCheckpointStore } from "../services/sync-checkpoint-store.js";
 import { SyncReporter } from "../services/sync-reporter.js";
 import { SyncSettings } from "../services/sync-settings.js";
 import { StoreCleaner } from "../services/store-cleaner.js";
+import { StoreRenamer } from "../services/store-renamer.js";
 import { LinkValidator } from "../services/link-validator.js";
 import { TrendingTopics } from "../services/trending-topics.js";
 import { ResourceMonitor } from "../services/resource-monitor.js";
 import { CliOutput } from "./output.js";
+import { CliInput } from "./input.js";
 import { DerivationEngine } from "../services/derivation-engine.js";
 import { DerivationValidator } from "../services/derivation-validator.js";
 import { DerivationSettings } from "../services/derivation-settings.js";
@@ -114,6 +116,12 @@ const viewCheckpointLayer = ViewCheckpointStore.layer.pipe(
 const lineageLayer = LineageStore.layer.pipe(
   Layer.provideMerge(storageLayer)
 );
+const storeRenamerLayer = StoreRenamer.layer.pipe(
+  Layer.provideMerge(appConfigLayer),
+  Layer.provideMerge(managerLayer),
+  Layer.provideMerge(storeDbLayer),
+  Layer.provideMerge(lineageLayer)
+);
 const compilerLayer = FilterCompiler.layer;
 const postParserLayer = PostParser.layer;
 const derivationEngineLayer = DerivationEngine.layer.pipe(
@@ -157,6 +165,7 @@ export const CliLive = Layer.mergeAll(
   appConfigLayer,
   filterSettingsLayer,
   credentialLayer,
+  CliInput.layer,
   CliOutput.layer,
   resourceMonitorLayer,
   managerLayer,
@@ -164,6 +173,7 @@ export const CliLive = Layer.mergeAll(
   indexLayer,
   eventLogLayer,
   cleanerLayer,
+  storeRenamerLayer,
   syncLayer,
   checkpointLayer,
   viewCheckpointLayer,

package/src/cli/logging.ts

@@ -132,5 +132,13 @@ export const makeSyncReporter = (
             { discard: true }
           );
         }
+      }).pipe(Effect.orElseSucceed(() => undefined)),
+    warn: (message, data) =>
+      Effect.gen(function* () {
+        const format = yield* resolveLogFormat;
+        yield* logEventWith(output, format, "WARN", {
+          message,
+          ...data
+        });
       }).pipe(Effect.orElseSucceed(() => undefined))
   });

package/src/cli/option-schemas.ts

@@ -0,0 +1,22 @@
+import { Duration, Effect, ParseResult, Schema } from "effect";
+import { parseDurationInput } from "./time.js";
+
+export const PositiveInt = Schema.Int.pipe(Schema.greaterThan(0));
+
+export const NonNegativeInt = Schema.NonNegativeInt;
+
+export const boundedInt = (min: number, max: number) =>
+  Schema.Int.pipe(
+    Schema.greaterThanOrEqualTo(min),
+    Schema.lessThanOrEqualTo(max)
+  );
+
+export const DurationInput = Schema.transformOrFail(Schema.String, Schema.DurationFromSelf, {
+  strict: true,
+  decode: (raw, _options, ast) =>
+    parseDurationInput(raw).pipe(
+      Effect.mapError((error) => new ParseResult.Type(ast, raw, error.message))
+    ),
+  encode: (duration) =>
+    Effect.succeed(`${Duration.toMillis(duration)} millis`)
+}).pipe(Schema.greaterThanOrEqualToDuration(0));

package/src/cli/output-format.ts

@@ -13,6 +13,17 @@ export type TextJsonFormat = typeof textJsonFormats[number];
 export const treeTableJsonFormats = ["tree", "table", "json"] as const;
 export type TreeTableJsonFormat = typeof treeTableJsonFormats[number];
 
+export const queryOutputFormats = [
+  "json",
+  "ndjson",
+  "markdown",
+  "table",
+  "compact",
+  "card",
+  "thread"
+] as const;
+export type QueryOutputFormat = typeof queryOutputFormats[number];
+
 export const resolveOutputFormat = <T extends string>(
   format: Option.Option<T>,
   configFormat: OutputFormat,

package/src/cli/output-render.ts

@@ -0,0 +1,14 @@
+import { Effect, Option } from "effect";
+import type { OutputFormat } from "../domain/config.js";
+import { resolveOutputFormat } from "./output-format.js";
+
+export const emitWithFormat = <T extends string, E, R>(
+  format: Option.Option<T>,
+  configFormat: OutputFormat,
+  supported: readonly T[],
+  fallback: T,
+  handlers: { readonly [K in T]: Effect.Effect<unknown, E, R> }
+): Effect.Effect<unknown, E, R> => {
+  const resolved = resolveOutputFormat(format, configFormat, supported, fallback);
+  return handlers[resolved];
+};

package/src/cli/pagination.ts

@@ -0,0 +1,17 @@
+import { Options } from "@effect/cli";
+import { Option } from "effect";
+import { PositiveInt } from "./option-schemas.js";
+
+export const limitOption = Options.integer("limit").pipe(
+  Options.withSchema(PositiveInt),
+  Options.optional
+);
+export const cursorOption = Options.text("cursor").pipe(Options.optional);
+
+export const parsePagination = (
+  limit: Option.Option<number>,
+  cursor: Option.Option<string>
+) => ({
+  limit: Option.getOrUndefined(limit),
+  cursor: Option.getOrUndefined(cursor)
+});

package/src/cli/parse-errors.ts

@@ -0,0 +1,30 @@
+type ParseIssue = { readonly _tag: string; readonly message?: string };
+
+/** Safely parse JSON, returning `undefined` on failure. */
+export const safeParseJson = (raw: string): unknown => {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return undefined;
+  }
+};
+
+export const jsonParseTip = "Tip: wrap JSON in single quotes to avoid shell escaping issues.";
+
+export const findJsonParseIssue = (issues: ReadonlyArray<ParseIssue>) =>
+  issues.find(
+    (issue) =>
+      issue._tag === "Transformation" &&
+      typeof issue.message === "string" &&
+      issue.message.startsWith("JSON Parse error")
+  );
+
+/** Format schema issues into an array of "path: message" strings. */
+export const issueDetails = (
+  issues: ReadonlyArray<{ readonly path: ReadonlyArray<unknown>; readonly message: string }>
+) =>
+  issues.map((issue) => {
+    const path =
+      issue.path.length > 0 ? issue.path.map((entry) => String(entry)).join(".") : "value";
+    return `${path}: ${issue.message}`;
+  });

package/src/cli/parse.ts

@@ -1,52 +1,6 @@
 import { Effect, ParseResult, Schema } from "effect";
 import { CliJsonError } from "./errors.js";
-
-type FormatParseErrorOptions = {
-  readonly label?: string;
-  readonly maxIssues?: number;
-};
-
-const formatPath = (path: ReadonlyArray<unknown>) =>
-  path.length > 0 ? path.map((entry) => String(entry)).join(".") : "value";
-
-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");
-};
+import { formatParseError } from "./shared.js";
 
 type DecodeJsonOptions = {
   readonly formatter?: (error: ParseResult.ParseError, raw: string) => string;

package/src/cli/pipe-input.ts

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+import { RawPost } from "../domain/raw.js";
+import { Post } from "../domain/post.js";
+import { StoreName } from "../domain/primitives.js";
+
+export class StorePostInput extends Schema.Class<StorePostInput>("StorePostInput")({
+  store: StoreName,
+  post: Post
+}) {}
+
+export const PipeInput = Schema.Union(RawPost, Post, StorePostInput);
+export type PipeInput = typeof PipeInput.Type;
+
+export const isRawPostInput = (value: PipeInput): value is RawPost =>
+  typeof value === "object" && value !== null && "record" in value;
+
+export const isStorePostInput = (value: PipeInput): value is StorePostInput =>
+  typeof value === "object" && value !== null && "post" in value;

package/src/cli/pipe.ts

@@ -0,0 +1,154 @@
+import { Command, Options } from "@effect/cli";
+import { Chunk, Effect, Option, Ref, Stream } from "effect";
+import { ParseResult } from "effect";
+import type { Post } from "../domain/post.js";
+import { FilterRuntime } from "../services/filter-runtime.js";
+import { PostParser } from "../services/post-parser.js";
+import { CliInput } from "./input.js";
+import { CliInputError, CliJsonError } from "./errors.js";
+import { parseFilterExpr } from "./filter-input.js";
+import { decodeJson } from "./parse.js";
+import { PipeInput, isRawPostInput, isStorePostInput } from "./pipe-input.js";
+import { withExamples } from "./help.js";
+import { filterOption, filterJsonOption } from "./shared-options.js";
+import { formatSchemaError } from "./shared.js";
+import { writeJsonStream } from "./output.js";
+import { filterByFlags } from "../typeclass/chunk.js";
+import { logErrorEvent, logWarn } from "./logging.js";
+import { PositiveInt } from "./option-schemas.js";
+
+const onErrorOption = Options.choice("on-error", ["fail", "skip", "report"]).pipe(
+  Options.withDescription("Behavior on invalid input lines"),
+  Options.withDefault("fail" as const)
+);
+
+const batchSizeOption = Options.integer("batch-size").pipe(
+  Options.withSchema(PositiveInt),
+  Options.withDescription("Posts per filter batch (default: 50)"),
+  Options.optional
+);
+
+const requireFilterExpr = (
+  filter: Option.Option<string>,
+  filterJson: Option.Option<string>
+) =>
+  Option.isNone(filter) && Option.isNone(filterJson)
+    ? Effect.fail(
+        CliInputError.make({
+          message: "Provide --filter or --filter-json.",
+          cause: { filter: null, filterJson: null }
+        })
+      )
+    : Effect.void;
+
+const truncate = (value: string, max = 500) =>
+  value.length > max ? `${value.slice(0, max)}...` : value;
+
+const formatPipeError = (error: unknown) => {
+  if (error instanceof CliJsonError || error instanceof CliInputError) {
+    return error.message;
+  }
+  if (ParseResult.isParseError(error)) {
+    return formatSchemaError(error);
+  }
+  if (typeof error === "object" && error !== null && "message" in error) {
+    const message = (error as { readonly message?: unknown }).message;
+    if (typeof message === "string" && message.length > 0) {
+      return message;
+    }
+  }
+  return String(error);
+};
+
+export const pipeCommand = Command.make(
+  "pipe",
+  { filter: filterOption, filterJson: filterJsonOption, onError: onErrorOption, batchSize: batchSizeOption },
+  ({ filter, filterJson, onError, batchSize }) =>
+    Effect.gen(function* () {
+      if (process.stdin.isTTY) {
+        return yield* CliInputError.make({
+          message: "stdin is a TTY. Pipe NDJSON input into skygent pipe.",
+          cause: { isTTY: true }
+        });
+      }
+      yield* requireFilterExpr(filter, filterJson);
+
+      const input = yield* CliInput;
+      const parser = yield* PostParser;
+      const runtime = yield* FilterRuntime;
+      const expr = yield* parseFilterExpr(filter, filterJson);
+      const evaluateBatch = yield* runtime.evaluateBatch(expr);
+
+      const size = Option.getOrElse(batchSize, () => 50);
+
+      const lineRef = yield* Ref.make(0);
+      const parsed = input.lines.pipe(
+        Stream.map((line) => line.trim()),
+        Stream.filter((line) => line.length > 0),
+        Stream.mapEffect((line) =>
+          Ref.updateAndGet(lineRef, (value) => value + 1).pipe(
+            Effect.map((lineNumber) => ({ line, lineNumber }))
+          )
+        ),
+        Stream.mapEffect(({ line, lineNumber }) =>
+          decodeJson(PipeInput, line).pipe(
+            Effect.flatMap((inputPost) => {
+              if (isRawPostInput(inputPost)) {
+                return parser.parsePost(inputPost);
+              }
+              if (isStorePostInput(inputPost)) {
+                return Effect.succeed(inputPost.post);
+              }
+              return Effect.succeed(inputPost);
+            }),
+            Effect.map(Option.some),
+            Effect.catchAll((error) => {
+              if (onError === "fail") {
+                return Effect.fail(error);
+              }
+              const message = formatPipeError(error);
+              const payload = {
+                line: lineNumber,
+                message,
+                input: truncate(line)
+              };
+              const log =
+                onError === "report"
+                  ? logErrorEvent("Invalid input line", payload)
+                  : logWarn("Skipping invalid input line", payload);
+              return log.pipe(
+                Effect.ignore,
+                Effect.as(Option.none<Post>())
+              );
+            })
+          )
+        ),
+        Stream.filterMap((value) => value)
+      );
+
+      const filtered = parsed.pipe(
+        Stream.grouped(size),
+        Stream.mapEffect((batch) =>
+          evaluateBatch(batch).pipe(
+            Effect.map((flags) => filterByFlags(batch, flags))
+          )
+        ),
+        Stream.mapConcat((chunk) => Chunk.toReadonlyArray(chunk))
+      );
+
+      yield* writeJsonStream(filtered);
+    })
+).pipe(
+  Command.withDescription(
+    withExamples(
+      "Filter raw post NDJSON from stdin",
+      [
+        "skygent pipe --filter 'hashtag:#ai' < posts.ndjson",
+        "cat posts.ndjson | skygent pipe --filter-json '{\"_tag\":\"All\"}'"
+      ],
+      [
+        "Note: stdin must be raw post NDJSON or skygent post NDJSON (from query --format ndjson)."
+      ]
+    )
+  )
+);

package/src/cli/post.ts

@@ -2,24 +2,29 @@ import { Command, Options } from "@effect/cli";
 import { Context, Effect, Option, Stream } from "effect";
 import { BskyClient } from "../services/bsky-client.js";
 import { PostParser } from "../services/post-parser.js";
-import type { PostLike, ProfileView } from "../domain/bsky.js";
+import type { PostLike } from "../domain/bsky.js";
 import type { RawPost } from "../domain/raw.js";
 import { renderPostsTable } from "../domain/format.js";
 import { AppConfigService } from "../services/app-config.js";
 import { withExamples } from "./help.js";
-import { postUriArg, parseLimit } from "./shared-options.js";
+import { postUriArg } from "./shared-options.js";
+import { PostCid } from "../domain/primitives.js";
 import { writeJson, writeJsonStream, writeText } from "./output.js";
 import { renderTableLegacy } from "./doc/table.js";
-import { jsonNdjsonTableFormats, resolveOutputFormat } from "./output-format.js";
+import { renderProfileTable } from "./doc/table-renderers.js";
+import { jsonNdjsonTableFormats } from "./output-format.js";
+import { emitWithFormat } from "./output-render.js";
+import { cursorOption as baseCursorOption, limitOption as baseLimitOption, parsePagination } from "./pagination.js";
+import { CliInputError } from "./errors.js";
+import { CliPreferences } from "./preferences.js";
+import { compactPost, compactPostLike, compactProfileView } from "./compact-output.js";
 
-const limitOption = Options.integer("limit").pipe(
-  Options.withDescription("Maximum number of results"),
-  Options.optional
+const limitOption = baseLimitOption.pipe(
+  Options.withDescription("Maximum number of results")
 );
 
-const cursorOption = Options.text("cursor").pipe(
-  Options.withDescription("Pagination cursor"),
-  Options.optional
+const cursorOption = baseCursorOption.pipe(
+  Options.withDescription("Pagination cursor")
 );
 
 const formatOption = Options.choice("format", jsonNdjsonTableFormats).pipe(
@@ -27,23 +32,23 @@ const formatOption = Options.choice("format", jsonNdjsonTableFormats).pipe(
   Options.optional
 );
 
+const ensureSupportedFormat = (
+  format: Option.Option<typeof jsonNdjsonTableFormats[number]>,
+  configFormat: string
+) =>
+  Option.isNone(format) && configFormat === "markdown"
+    ? CliInputError.make({
+        message: 'Output format "markdown" is not supported for post commands. Use --format json|ndjson|table.',
+        cause: { format: configFormat }
+      })
+    : Effect.void;
+
 const cidOption = Options.text("cid").pipe(
+  Options.withSchema(PostCid),
   Options.withDescription("Filter engagement by specific record CID"),
   Options.optional
 );
 
-const renderProfileTable = (
-  actors: ReadonlyArray<ProfileView>,
-  cursor: string | undefined
-) => {
-  const rows = actors.map((actor) => [
-    actor.handle,
-    actor.displayName ?? "",
-    actor.did
-  ]);
-  const table = renderTableLegacy(["HANDLE", "DISPLAY NAME", "DID"], rows);
-  return cursor ? `${table}\n\nCursor: ${cursor}` : table;
-};
 
 const renderLikesTable = (likes: ReadonlyArray<PostLike>, cursor: string | undefined) => {
   const rows = likes.map((like) => [
@@ -71,28 +76,33 @@ const likesCommand = Command.make(
   ({ uri, cid, limit, cursor, format }) =>
     Effect.gen(function* () {
       const appConfig = yield* AppConfigService;
+      yield* ensureSupportedFormat(format, appConfig.outputFormat);
+      const preferences = yield* CliPreferences;
       const client = yield* BskyClient;
-      const parsedLimit = yield* parseLimit(limit);
+      const { limit: limitValue, cursor: cursorValue } = parsePagination(limit, cursor);
       const result = yield* client.getLikes(uri, {
-        ...(Option.isSome(parsedLimit) ? { limit: parsedLimit.value } : {}),
-        ...(Option.isSome(cursor) ? { cursor: cursor.value } : {}),
+        ...(limitValue !== undefined ? { limit: limitValue } : {}),
+        ...(cursorValue !== undefined ? { cursor: cursorValue } : {}),
         ...(Option.isSome(cid) ? { cid: cid.value } : {})
       });
-      const outputFormat = resolveOutputFormat(
+      const likes = preferences.compact
+        ? result.likes.map(compactPostLike)
+        : result.likes;
+      const payload = result.cursor ? { likes, cursor: result.cursor } : { likes };
+      const likesStream = Stream.fromIterable(
+        likes as ReadonlyArray<unknown>
+      );
+      yield* emitWithFormat(
         format,
         appConfig.outputFormat,
         jsonNdjsonTableFormats,
-        "json"
+        "json",
+        {
+          json: writeJson(payload),
+          ndjson: writeJsonStream(likesStream),
+          table: writeText(renderLikesTable(result.likes, result.cursor))
+        }
       );
-      if (outputFormat === "ndjson") {
-        yield* writeJsonStream(Stream.fromIterable(result.likes));
-        return;
-      }
-      if (outputFormat === "table") {
-        yield* writeText(renderLikesTable(result.likes, result.cursor));
-        return;
-      }
-      yield* writeJson(result);
     })
 ).pipe(
   Command.withDescription(
@@ -109,28 +119,35 @@ const repostedByCommand = Command.make(
   ({ uri, cid, limit, cursor, format }) =>
     Effect.gen(function* () {
       const appConfig = yield* AppConfigService;
+      yield* ensureSupportedFormat(format, appConfig.outputFormat);
+      const preferences = yield* CliPreferences;
       const client = yield* BskyClient;
-      const parsedLimit = yield* parseLimit(limit);
+      const { limit: limitValue, cursor: cursorValue } = parsePagination(limit, cursor);
       const result = yield* client.getRepostedBy(uri, {
-        ...(Option.isSome(parsedLimit) ? { limit: parsedLimit.value } : {}),
-        ...(Option.isSome(cursor) ? { cursor: cursor.value } : {}),
+        ...(limitValue !== undefined ? { limit: limitValue } : {}),
+        ...(cursorValue !== undefined ? { cursor: cursorValue } : {}),
         ...(Option.isSome(cid) ? { cid: cid.value } : {})
       });
-      const outputFormat = resolveOutputFormat(
+      const repostedBy = preferences.compact
+        ? result.repostedBy.map(compactProfileView)
+        : result.repostedBy;
+      const payload = result.cursor
+        ? { repostedBy, cursor: result.cursor }
+        : { repostedBy };
+      const repostedStream = Stream.fromIterable(
+        repostedBy as ReadonlyArray<unknown>
+      );
+      yield* emitWithFormat(
         format,
         appConfig.outputFormat,
         jsonNdjsonTableFormats,
-        "json"
+        "json",
+        {
+          json: writeJson(payload),
+          ndjson: writeJsonStream(repostedStream),
+          table: writeText(renderProfileTable(result.repostedBy, result.cursor))
+        }
       );
-      if (outputFormat === "ndjson") {
-        yield* writeJsonStream(Stream.fromIterable(result.repostedBy));
-        return;
-      }
-      if (outputFormat === "table") {
-        yield* writeText(renderProfileTable(result.repostedBy, result.cursor));
-        return;
-      }
-      yield* writeJson(result);
     })
 ).pipe(
   Command.withDescription(
@@ -146,33 +163,38 @@ const quotesCommand = Command.make(
   ({ uri, cid, limit, cursor, format }) =>
     Effect.gen(function* () {
       const appConfig = yield* AppConfigService;
+      yield* ensureSupportedFormat(format, appConfig.outputFormat);
+      const preferences = yield* CliPreferences;
       const client = yield* BskyClient;
       const parser = yield* PostParser;
-      const parsedLimit = yield* parseLimit(limit);
+      const { limit: limitValue, cursor: cursorValue } = parsePagination(limit, cursor);
       const result = yield* client.getQuotes(uri, {
-        ...(Option.isSome(parsedLimit) ? { limit: parsedLimit.value } : {}),
-        ...(Option.isSome(cursor) ? { cursor: cursor.value } : {}),
+        ...(limitValue !== undefined ? { limit: limitValue } : {}),
+        ...(cursorValue !== undefined ? { cursor: cursorValue } : {}),
         ...(Option.isSome(cid) ? { cid: cid.value } : {})
       });
       const posts = yield* parseRawPosts(parser, result.posts);
-      const outputFormat = resolveOutputFormat(
+      const compactPosts = preferences.compact
+        ? posts.map(compactPost)
+        : posts;
+      const payload = {
+        ...result,
+        posts: compactPosts
+      };
+      const postStream = Stream.fromIterable(
+        compactPosts as ReadonlyArray<unknown>
+      );
+      yield* emitWithFormat(
         format,
         appConfig.outputFormat,
         jsonNdjsonTableFormats,
-        "json"
+        "json",
+        {
+          json: writeJson(payload),
+          ndjson: writeJsonStream(postStream),
+          table: writeText(renderPostsTable(posts))
+        }
       );
-      if (outputFormat === "ndjson") {
-        yield* writeJsonStream(Stream.fromIterable(posts));
-        return;
-      }
-      if (outputFormat === "table") {
-        yield* writeText(renderPostsTable(posts));
-        return;
-      }
-      yield* writeJson({
-        ...result,
-        posts
-      });
     })
 ).pipe(
   Command.withDescription(