@mepuka/skygent 0.3.0 → 0.3.1

package/src/cli/graph.ts

@@ -5,7 +5,8 @@ import { AppConfigService } from "../services/app-config.js";
 import { IdentityResolver } from "../services/identity-resolver.js";
 import { ProfileResolver } from "../services/profile-resolver.js";
 import type { ListItemView, ListView } from "../domain/bsky.js";
-import { decodeActor } from "./shared-options.js";
+import { AtUri } from "../domain/primitives.js";
+import { actorArg, decodeActor } from "./shared-options.js";
 import { CliInputError } from "./errors.js";
 import { withExamples } from "./help.js";
 import { writeJson, writeJsonStream, writeText } from "./output.js";
@@ -14,6 +15,8 @@ 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 { CliPreferences } from "./preferences.js";
+import { compactListItemView, compactListView, compactProfileView } from "./compact-output.js";
 import {
   buildRelationshipGraph,
   relationshipEntries,
@@ -21,11 +24,8 @@ import {
   type RelationshipNode
 } from "../graph/relationships.js";
 
-const actorArg = Args.text({ name: "actor" }).pipe(
-  Args.withDescription("Bluesky handle or DID")
-);
-
 const listUriArg = Args.text({ name: "uri" }).pipe(
+  Args.withSchema(AtUri),
   Args.withDescription("Bluesky list URI (at://...)")
 );
 
@@ -42,6 +42,17 @@ 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 graph commands. Use --format json|ndjson|table.',
+        cause: { format: configFormat }
+      })
+    : Effect.void;
+
 const purposeOption = Options.choice("purpose", ["modlist", "curatelist"]).pipe(
   Options.withDescription("List purpose filter"),
   Options.optional
@@ -121,22 +132,35 @@ const followersCommand = Command.make(
   ({ actor, limit, cursor, format }) =>
     Effect.gen(function* () {
       const appConfig = yield* AppConfigService;
+      yield* ensureSupportedFormat(format, appConfig.outputFormat);
+      const preferences = yield* CliPreferences;
       const client = yield* BskyClient;
-      const resolvedActor = yield* decodeActor(actor);
-      const { limit: limitValue, cursor: cursorValue } = yield* parsePagination(limit, cursor);
+      const { limit: limitValue, cursor: cursorValue } = parsePagination(limit, cursor);
       const options = {
         ...(limitValue !== undefined ? { limit: limitValue } : {}),
         ...(cursorValue !== undefined ? { cursor: cursorValue } : {})
       };
-      const result = yield* client.getFollowers(resolvedActor, options);
+      const result = yield* client.getFollowers(actor, options);
+      const subject = preferences.compact
+        ? compactProfileView(result.subject)
+        : result.subject;
+      const followers = preferences.compact
+        ? result.followers.map(compactProfileView)
+        : result.followers;
+      const payload = result.cursor
+        ? { subject, followers, cursor: result.cursor }
+        : { subject, followers };
+      const followersStream = Stream.fromIterable(
+        followers as ReadonlyArray<unknown>
+      );
       yield* emitWithFormat(
         format,
         appConfig.outputFormat,
         jsonNdjsonTableFormats,
         "json",
         {
-          json: writeJson(result),
-          ndjson: writeJsonStream(Stream.fromIterable(result.followers)),
+          json: writeJson(payload),
+          ndjson: writeJsonStream(followersStream),
           table: writeText(renderProfileTable(result.followers, result.cursor))
         }
       );
@@ -156,22 +180,35 @@ const followsCommand = Command.make(
   ({ actor, limit, cursor, format }) =>
     Effect.gen(function* () {
       const appConfig = yield* AppConfigService;
+      yield* ensureSupportedFormat(format, appConfig.outputFormat);
+      const preferences = yield* CliPreferences;
       const client = yield* BskyClient;
-      const resolvedActor = yield* decodeActor(actor);
-      const { limit: limitValue, cursor: cursorValue } = yield* parsePagination(limit, cursor);
+      const { limit: limitValue, cursor: cursorValue } = parsePagination(limit, cursor);
       const options = {
         ...(limitValue !== undefined ? { limit: limitValue } : {}),
         ...(cursorValue !== undefined ? { cursor: cursorValue } : {})
       };
-      const result = yield* client.getFollows(resolvedActor, options);
+      const result = yield* client.getFollows(actor, options);
+      const subject = preferences.compact
+        ? compactProfileView(result.subject)
+        : result.subject;
+      const follows = preferences.compact
+        ? result.follows.map(compactProfileView)
+        : result.follows;
+      const payload = result.cursor
+        ? { subject, follows, cursor: result.cursor }
+        : { subject, follows };
+      const followsStream = Stream.fromIterable(
+        follows as ReadonlyArray<unknown>
+      );
       yield* emitWithFormat(
         format,
         appConfig.outputFormat,
         jsonNdjsonTableFormats,
         "json",
         {
-          json: writeJson(result),
-          ndjson: writeJsonStream(Stream.fromIterable(result.follows)),
+          json: writeJson(payload),
+          ndjson: writeJsonStream(followsStream),
           table: writeText(renderProfileTable(result.follows, result.cursor))
         }
       );
@@ -191,22 +228,35 @@ const knownFollowersCommand = Command.make(
   ({ actor, limit, cursor, format }) =>
     Effect.gen(function* () {
       const appConfig = yield* AppConfigService;
+      yield* ensureSupportedFormat(format, appConfig.outputFormat);
+      const preferences = yield* CliPreferences;
       const client = yield* BskyClient;
-      const resolvedActor = yield* decodeActor(actor);
-      const { limit: limitValue, cursor: cursorValue } = yield* parsePagination(limit, cursor);
+      const { limit: limitValue, cursor: cursorValue } = parsePagination(limit, cursor);
       const options = {
         ...(limitValue !== undefined ? { limit: limitValue } : {}),
         ...(cursorValue !== undefined ? { cursor: cursorValue } : {})
       };
-      const result = yield* client.getKnownFollowers(resolvedActor, options);
+      const result = yield* client.getKnownFollowers(actor, options);
+      const subject = preferences.compact
+        ? compactProfileView(result.subject)
+        : result.subject;
+      const followers = preferences.compact
+        ? result.followers.map(compactProfileView)
+        : result.followers;
+      const payload = result.cursor
+        ? { subject, followers, cursor: result.cursor }
+        : { subject, followers };
+      const followersStream = Stream.fromIterable(
+        followers as ReadonlyArray<unknown>
+      );
       yield* emitWithFormat(
         format,
         appConfig.outputFormat,
         jsonNdjsonTableFormats,
         "json",
         {
-          json: writeJson(result),
-          ndjson: writeJsonStream(Stream.fromIterable(result.followers)),
+          json: writeJson(payload),
+          ndjson: writeJsonStream(followersStream),
           table: writeText(renderProfileTable(result.followers, result.cursor))
         }
       );
@@ -225,6 +275,7 @@ const relationshipsCommand = Command.make(
   ({ actor, others, format, raw }) =>
     Effect.gen(function* () {
       const appConfig = yield* AppConfigService;
+      yield* ensureSupportedFormat(format, appConfig.outputFormat);
       const client = yield* BskyClient;
       const identities = yield* IdentityResolver;
       const profiles = yield* ProfileResolver;
@@ -236,7 +287,9 @@ const relationshipsCommand = Command.make(
             ? actorValue
             : yield* identities.resolveDid(actorValue);
         });
-      const resolvedActor = yield* resolveDid(actor);
+      const resolvedActor = actor.startsWith("did:")
+        ? actor
+        : yield* identities.resolveDid(actor);
       const parsedOthers = others
         .split(",")
         .map((item) => item.trim())
@@ -352,23 +405,31 @@ const listsCommand = Command.make(
   ({ actor, limit, cursor, purpose, format }) =>
     Effect.gen(function* () {
       const appConfig = yield* AppConfigService;
+      yield* ensureSupportedFormat(format, appConfig.outputFormat);
+      const preferences = yield* CliPreferences;
       const client = yield* BskyClient;
-      const resolvedActor = yield* decodeActor(actor);
-      const { limit: limitValue, cursor: cursorValue } = yield* parsePagination(limit, cursor);
+      const { limit: limitValue, cursor: cursorValue } = parsePagination(limit, cursor);
       const options = {
         ...(limitValue !== undefined ? { limit: limitValue } : {}),
         ...(cursorValue !== undefined ? { cursor: cursorValue } : {}),
         ...(Option.isSome(purpose) ? { purposes: [purpose.value] } : {})
       };
-      const result = yield* client.getLists(resolvedActor, options);
+      const result = yield* client.getLists(actor, options);
+      const lists = preferences.compact
+        ? result.lists.map(compactListView)
+        : result.lists;
+      const payload = result.cursor ? { lists, cursor: result.cursor } : { lists };
+      const listsStream = Stream.fromIterable(
+        lists as ReadonlyArray<ListView | ReturnType<typeof compactListView>>
+      );
       yield* emitWithFormat(
         format,
         appConfig.outputFormat,
         jsonNdjsonTableFormats,
         "json",
         {
-          json: writeJson(result),
-          ndjson: writeJsonStream(Stream.fromIterable(result.lists)),
+          json: writeJson(payload),
+          ndjson: writeJsonStream(listsStream),
           table: writeText(renderListTable(result.lists, result.cursor))
         }
       );
@@ -388,13 +449,25 @@ const listCommand = Command.make(
   ({ uri, limit, cursor, format }) =>
     Effect.gen(function* () {
       const appConfig = yield* AppConfigService;
+      yield* ensureSupportedFormat(format, appConfig.outputFormat);
+      const preferences = yield* CliPreferences;
       const client = yield* BskyClient;
-      const { limit: limitValue, cursor: cursorValue } = yield* parsePagination(limit, cursor);
+      const { limit: limitValue, cursor: cursorValue } = parsePagination(limit, cursor);
       const options = {
         ...(limitValue !== undefined ? { limit: limitValue } : {}),
         ...(cursorValue !== undefined ? { cursor: cursorValue } : {})
       };
       const result = yield* client.getList(uri, options);
+      const list = preferences.compact ? compactListView(result.list) : result.list;
+      const items = preferences.compact
+        ? result.items.map(compactListItemView)
+        : result.items;
+      const payload = result.cursor
+        ? { list, items, cursor: result.cursor }
+        : { list, items };
+      const itemsStream = Stream.fromIterable(
+        items as ReadonlyArray<ListItemView | ReturnType<typeof compactListItemView>>
+      );
       const header = `${result.list.name} (${result.list.purpose}) by ${result.list.creator.handle}`;
       const body = renderListItemsTable(result.items, result.cursor);
       yield* emitWithFormat(
@@ -403,8 +476,8 @@ const listCommand = Command.make(
         jsonNdjsonTableFormats,
         "json",
         {
-          json: writeJson(result),
-          ndjson: writeJsonStream(Stream.fromIterable(result.items)),
+          json: writeJson(payload),
+          ndjson: writeJsonStream(itemsStream),
           table: writeText(`${header}\n\n${body}`)
         }
       );
@@ -423,24 +496,33 @@ const blocksCommand = Command.make(
   ({ limit, cursor, format }) =>
     Effect.gen(function* () {
       const appConfig = yield* AppConfigService;
+      yield* ensureSupportedFormat(format, appConfig.outputFormat);
+      const preferences = yield* CliPreferences;
       const client = yield* BskyClient;
-      const { limit: limitValue, cursor: cursorValue } = yield* parsePagination(limit, cursor);
+      const { limit: limitValue, cursor: cursorValue } = parsePagination(limit, cursor);
       const options = {
         ...(limitValue !== undefined ? { limit: limitValue } : {}),
         ...(cursorValue !== undefined ? { cursor: cursorValue } : {})
       };
       const result = yield* client.getBlocks(options);
+      const blocks = preferences.compact
+        ? result.blocks.map(compactProfileView)
+        : result.blocks;
+      const payload = result.cursor ? { blocks, cursor: result.cursor } : { blocks };
+      const blocksStream = Stream.fromIterable(
+        blocks as ReadonlyArray<unknown>
+      );
       yield* emitWithFormat(
         format,
         appConfig.outputFormat,
         jsonNdjsonTableFormats,
         "json",
         {
-          json: writeJson(result),
+          json: writeJson(payload),
           ndjson:
-            result.blocks.length === 0
+            blocks.length === 0
               ? writeText("[]")
-              : writeJsonStream(Stream.fromIterable(result.blocks)),
+              : writeJsonStream(blocksStream),
           table: writeText(renderProfileTable(result.blocks, result.cursor))
         }
       );
@@ -459,24 +541,33 @@ const mutesCommand = Command.make(
   ({ limit, cursor, format }) =>
     Effect.gen(function* () {
       const appConfig = yield* AppConfigService;
+      yield* ensureSupportedFormat(format, appConfig.outputFormat);
+      const preferences = yield* CliPreferences;
       const client = yield* BskyClient;
-      const { limit: limitValue, cursor: cursorValue } = yield* parsePagination(limit, cursor);
+      const { limit: limitValue, cursor: cursorValue } = parsePagination(limit, cursor);
       const options = {
         ...(limitValue !== undefined ? { limit: limitValue } : {}),
         ...(cursorValue !== undefined ? { cursor: cursorValue } : {})
       };
       const result = yield* client.getMutes(options);
+      const mutes = preferences.compact
+        ? result.mutes.map(compactProfileView)
+        : result.mutes;
+      const payload = result.cursor ? { mutes, cursor: result.cursor } : { mutes };
+      const mutesStream = Stream.fromIterable(
+        mutes as ReadonlyArray<unknown>
+      );
       yield* emitWithFormat(
         format,
         appConfig.outputFormat,
         jsonNdjsonTableFormats,
         "json",
         {
-          json: writeJson(result),
+          json: writeJson(payload),
           ndjson:
-            result.mutes.length === 0
+            mutes.length === 0
               ? writeText("[]")
-              : writeJsonStream(Stream.fromIterable(result.mutes)),
+              : writeJsonStream(mutesStream),
           table: writeText(renderProfileTable(result.mutes, result.cursor))
         }
       );

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/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/pagination.ts

@@ -1,18 +1,17 @@
 import { Options } from "@effect/cli";
-import { Effect, Option } from "effect";
-import { parseLimit } from "./shared-options.js";
+import { Option } from "effect";
+import { PositiveInt } from "./option-schemas.js";
 
-export const limitOption = Options.integer("limit").pipe(Options.optional);
+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>
-) =>
-  Effect.gen(function* () {
-    const parsedLimit = yield* parseLimit(limit);
-    return {
-      limit: Option.getOrUndefined(parsedLimit),
-      cursor: Option.getOrUndefined(cursor)
-    };
-  });
+) => ({
+  limit: Option.getOrUndefined(limit),
+  cursor: Option.getOrUndefined(cursor)
+});

package/src/cli/parse-errors.ts

@@ -1,3 +1,5 @@
+type ParseIssue = { readonly _tag: string; readonly message?: string };
+
 /** Safely parse JSON, returning `undefined` on failure. */
 export const safeParseJson = (raw: string): unknown => {
   try {
@@ -7,6 +9,16 @@ export const safeParseJson = (raw: string): unknown => {
   }
 };
 
+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 }>

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

@@ -1,7 +1,6 @@
 import { Command, Options } from "@effect/cli";
 import { Chunk, Effect, Option, Ref, Stream } from "effect";
 import { ParseResult } from "effect";
-import { RawPost } from "../domain/raw.js";
 import type { Post } from "../domain/post.js";
 import { FilterRuntime } from "../services/filter-runtime.js";
 import { PostParser } from "../services/post-parser.js";
@@ -9,12 +8,14 @@ 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, writeText } from "./output.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"),
@@ -22,6 +23,7 @@ const onErrorOption = Options.choice("on-error", ["fail", "skip", "report"]).pip
 );
 
 const batchSizeOption = Options.integer("batch-size").pipe(
+  Options.withSchema(PositiveInt),
   Options.withDescription("Posts per filter batch (default: 50)"),
   Options.optional
 );
@@ -78,16 +80,8 @@ export const pipeCommand = Command.make(
       const evaluateBatch = yield* runtime.evaluateBatch(expr);
 
       const size = Option.getOrElse(batchSize, () => 50);
-      if (size <= 0) {
-        return yield* CliInputError.make({
-          message: "--batch-size must be a positive integer.",
-          cause: { batchSize: size }
-        });
-      }
 
       const lineRef = yield* Ref.make(0);
-      const countRef = yield* Ref.make(0);
-
       const parsed = input.lines.pipe(
         Stream.map((line) => line.trim()),
         Stream.filter((line) => line.length > 0),
@@ -97,8 +91,16 @@ export const pipeCommand = Command.make(
           )
         ),
         Stream.mapEffect(({ line, lineNumber }) =>
-          decodeJson(RawPost, line).pipe(
-            Effect.flatMap((raw) => parser.parsePost(raw)),
+          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") {
@@ -131,15 +133,10 @@ export const pipeCommand = Command.make(
             Effect.map((flags) => filterByFlags(batch, flags))
           )
         ),
-        Stream.mapConcat((chunk) => Chunk.toReadonlyArray(chunk)),
-        Stream.tap(() => Ref.update(countRef, (count) => count + 1))
+        Stream.mapConcat((chunk) => Chunk.toReadonlyArray(chunk))
       );
 
       yield* writeJsonStream(filtered);
-      const count = yield* Ref.get(countRef);
-      if (count === 0) {
-        yield* writeText("[]");
-      }
     })
 ).pipe(
   Command.withDescription(
@@ -150,7 +147,7 @@ export const pipeCommand = Command.make(
         "cat posts.ndjson | skygent pipe --filter-json '{\"_tag\":\"All\"}'"
       ],
       [
-        "Note: stdin must be raw post NDJSON (app.bsky.feed.getPosts result)."
+        "Note: stdin must be raw post NDJSON or skygent post NDJSON (from query --format ndjson)."
       ]
     )
   )