@mepuka/skygent 0.3.0 → 0.3.1

package/src/cli/post.ts

@@ -8,12 +8,16 @@ import { renderPostsTable } from "../domain/format.js";
 import { AppConfigService } from "../services/app-config.js";
 import { withExamples } from "./help.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 { 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 = baseLimitOption.pipe(
   Options.withDescription("Maximum number of results")
@@ -28,7 +32,19 @@ 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
 );
@@ -60,21 +76,30 @@ 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 { limit: limitValue, cursor: cursorValue } = yield* parsePagination(limit, cursor);
+      const { limit: limitValue, cursor: cursorValue } = parsePagination(limit, cursor);
       const result = yield* client.getLikes(uri, {
         ...(limitValue !== undefined ? { limit: limitValue } : {}),
         ...(cursorValue !== undefined ? { cursor: cursorValue } : {}),
         ...(Option.isSome(cid) ? { cid: cid.value } : {})
       });
+      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: writeJson(result),
-          ndjson: writeJsonStream(Stream.fromIterable(result.likes)),
+          json: writeJson(payload),
+          ndjson: writeJsonStream(likesStream),
           table: writeText(renderLikesTable(result.likes, result.cursor))
         }
       );
@@ -94,21 +119,32 @@ 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 { limit: limitValue, cursor: cursorValue } = yield* parsePagination(limit, cursor);
+      const { limit: limitValue, cursor: cursorValue } = parsePagination(limit, cursor);
       const result = yield* client.getRepostedBy(uri, {
         ...(limitValue !== undefined ? { limit: limitValue } : {}),
         ...(cursorValue !== undefined ? { cursor: cursorValue } : {}),
         ...(Option.isSome(cid) ? { cid: cid.value } : {})
       });
+      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: writeJson(result),
-          ndjson: writeJsonStream(Stream.fromIterable(result.repostedBy)),
+          json: writeJson(payload),
+          ndjson: writeJsonStream(repostedStream),
           table: writeText(renderProfileTable(result.repostedBy, result.cursor))
         }
       );
@@ -127,26 +163,35 @@ 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 { limit: limitValue, cursor: cursorValue } = yield* parsePagination(limit, cursor);
+      const { limit: limitValue, cursor: cursorValue } = parsePagination(limit, cursor);
       const result = yield* client.getQuotes(uri, {
         ...(limitValue !== undefined ? { limit: limitValue } : {}),
         ...(cursorValue !== undefined ? { cursor: cursorValue } : {}),
         ...(Option.isSome(cid) ? { cid: cid.value } : {})
       });
       const posts = yield* parseRawPosts(parser, result.posts);
+      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: writeJson({
-            ...result,
-            posts
-          }),
-          ndjson: writeJsonStream(Stream.fromIterable(posts)),
+          json: writeJson(payload),
+          ndjson: writeJsonStream(postStream),
           table: writeText(renderPostsTable(posts))
         }
       );

package/src/cli/query-fields.ts

@@ -7,6 +7,11 @@ type FieldSelector = {
   readonly raw: string;
 };
 
+export type FieldSelectorsResolution = {
+  readonly selectors: Option.Option<ReadonlyArray<FieldSelector>>;
+  readonly source: "implicit" | "explicit";
+};
+
 const fieldPresets: Record<string, ReadonlyArray<string>> = {
   minimal: ["uri", "author", "text", "createdAt"],
   social: ["uri", "author", "text", "metrics", "hashtags"],
@@ -162,11 +167,16 @@ export const parseFieldSelectors = (
 export const resolveFieldSelectors = (
   fields: Option.Option<string>,
   compact: boolean
-): Effect.Effect<Option.Option<ReadonlyArray<FieldSelector>>, CliInputError> =>
+): Effect.Effect<FieldSelectorsResolution, CliInputError> =>
   Option.match(fields, {
     onNone: () =>
-      compact ? parseFieldSelectors("@minimal") : Effect.succeed(Option.none()),
-    onSome: (raw) => parseFieldSelectors(raw)
+      (compact ? parseFieldSelectors("@minimal") : Effect.succeed(Option.none())).pipe(
+        Effect.map((selectors) => ({ selectors, source: "implicit" as const }))
+      ),
+    onSome: (raw) =>
+      parseFieldSelectors(raw).pipe(
+        Effect.map((selectors) => ({ selectors, source: "explicit" as const }))
+      )
   });
 
 const getPathValue = (source: unknown, path: ReadonlyArray<string>): unknown => {

package/src/cli/query.ts

@@ -34,6 +34,8 @@ import { StoreNotFound } from "../domain/errors.js";
 import { StorePostOrder } from "../domain/order.js";
 import { formatSchemaError } from "./shared.js";
 import { mergeOrderedStreams } from "./stream-merge.js";
+import { queryOutputFormats, resolveOutputFormat } from "./output-format.js";
+import { PositiveInt } from "./option-schemas.js";
 
 const storeNamesArg = Args.text({ name: "store" }).pipe(
   Args.repeated,
@@ -56,10 +58,12 @@ const untilOption = Options.text("until").pipe(
   Options.optional
 );
 const limitOption = Options.integer("limit").pipe(
+  Options.withSchema(PositiveInt),
   Options.withDescription("Maximum number of posts to return"),
   Options.optional
 );
 const scanLimitOption = Options.integer("scan-limit").pipe(
+  Options.withSchema(PositiveInt),
   Options.withDescription("Maximum rows to scan before filtering (advanced)"),
   Options.optional
 );
@@ -70,15 +74,7 @@ const sortOption = Options.choice("sort", ["asc", "desc"]).pipe(
 const newestFirstOption = Options.boolean("newest-first").pipe(
   Options.withDescription("Sort newest posts first (alias for --sort desc)")
 );
-const formatOption = Options.choice("format", [
-  "json",
-  "ndjson",
-  "markdown",
-  "table",
-  "compact",
-  "card",
-  "thread"
-]).pipe(
+const formatOption = Options.choice("format", queryOutputFormats).pipe(
   Options.optional,
   Options.withDescription("Output format (default: config output format)")
 );
@@ -89,6 +85,7 @@ const ansiOption = Options.boolean("ansi").pipe(
   Options.withDescription("Enable ANSI colors in output")
 );
 const widthOption = Options.integer("width").pipe(
+  Options.withSchema(PositiveInt),
   Options.withDescription("Line width for terminal output"),
   Options.optional
 );
@@ -284,8 +281,11 @@ export const queryCommand = Command.make(
       const parsedRange = yield* parseRangeOptions(range, since, until);
       const parsedFilter = yield* parseOptionalFilterExpr(filter, filterJson);
       const expr = Option.getOrElse(parsedFilter, () => all());
-      const outputFormat = Option.getOrElse(format, () =>
-        appConfig.outputFormat === "ndjson" ? "compact" : appConfig.outputFormat
+      const outputFormat = resolveOutputFormat(
+        format,
+        appConfig.outputFormat,
+        queryOutputFormats,
+        "json"
       );
       if (multiStore && outputFormat === "thread") {
         return yield* CliInputError.make({
@@ -294,19 +294,20 @@ export const queryCommand = Command.make(
         });
       }
       const compact = preferences.compact;
-      const selectorsOption = yield* resolveFieldSelectors(fields, compact);
+      const { selectors: selectorsOption, source: selectorsSource } =
+        yield* resolveFieldSelectors(fields, compact);
       const project = (post: Post) =>
         Option.match(selectorsOption, {
           onNone: () => post,
           onSome: (selectors) => projectFields(post, selectors)
         });
-      if (Option.isSome(selectorsOption) && outputFormat !== "json" && outputFormat !== "ndjson") {
+      if (selectorsSource === "explicit" && outputFormat !== "json" && outputFormat !== "ndjson") {
         return yield* CliInputError.make({
           message: "--fields is only supported with json or ndjson output.",
           cause: { format: outputFormat }
         });
       }
-      if (count && Option.isSome(selectorsOption)) {
+      if (count && selectorsSource === "explicit") {
         return yield* CliInputError.make({
           message: "--count cannot be combined with --fields.",
           cause: { count, fields }
@@ -315,18 +316,6 @@ export const queryCommand = Command.make(
 
       const w = Option.getOrUndefined(width);
 
-      if (Option.isSome(limit) && limit.value <= 0) {
-        return yield* CliInputError.make({
-          message: "--limit must be a positive integer.",
-          cause: { limit: limit.value }
-        });
-      }
-      if (Option.isSome(scanLimit) && scanLimit.value <= 0) {
-        return yield* CliInputError.make({
-          message: "--scan-limit must be a positive integer.",
-          cause: { scanLimit: scanLimit.value }
-        });
-      }
       const sortValue = Option.getOrUndefined(sort);
       const order =
         newestFirst
@@ -366,13 +355,12 @@ export const queryCommand = Command.make(
       }
 
       if (
-        hasFilter &&
         Option.isNone(limit) &&
-        (outputFormat === "thread" || outputFormat === "table")
+        (outputFormat === "thread" || outputFormat === "table" || outputFormat === "markdown")
       ) {
         yield* output
           .writeStderr(
-            "Warning: thread/table output collects all matched posts in memory. Consider adding --limit."
+            "Warning: table/markdown/thread output collects all matched posts in memory. Consider adding --limit."
           )
           .pipe(Effect.catchAll(() => Effect.void));
       }
@@ -538,16 +526,7 @@ export const queryCommand = Command.make(
       }
 
       if (outputFormat === "ndjson") {
-        const countRef = yield* Ref.make(0);
-        const counted = stream.pipe(
-          Stream.map(toOutput),
-          Stream.tap(() => Ref.update(countRef, (count) => count + 1))
-        );
-        yield* writeJsonStream(counted);
-        const count = yield* Ref.get(countRef);
-        if (count === 0) {
-          yield* writeText("[]");
-        }
+        yield* writeJsonStream(stream.pipe(Stream.map(toOutput)));
         yield* warnIfScanLimitReached();
         return;
       }

package/src/cli/search.ts

@@ -6,17 +6,15 @@ import { PostParser } from "../services/post-parser.js";
 import { StoreIndex } from "../services/store-index.js";
 import { renderPostsTable } from "../domain/format.js";
 import { AppConfigService } from "../services/app-config.js";
-import { StoreName } from "../domain/primitives.js";
+import { ActorId, StoreName } from "../domain/primitives.js";
 import { storeOptions } from "./store.js";
 import { withExamples } from "./help.js";
 import { CliInputError } from "./errors.js";
-import { decodeActor } from "./shared-options.js";
 import { formatSchemaError } from "./shared.js";
 import { writeJson, writeJsonStream, writeText } from "./output.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 { parseLimit } from "./shared-options.js";
 
 const queryArg = Args.text({ name: "query" }).pipe(
   Args.withDescription("Search query string")
@@ -70,11 +68,13 @@ const untilOption = Options.text("until").pipe(
 );
 
 const mentionsOption = Options.text("mentions").pipe(
+  Options.withSchema(ActorId),
   Options.withDescription("Filter network results by mention (handle or DID)"),
   Options.optional
 );
 
 const authorOption = Options.text("author").pipe(
+  Options.withSchema(ActorId),
   Options.withDescription("Filter network results by author (handle or DID)"),
   Options.optional
 );
@@ -135,7 +135,7 @@ const handlesCommand = Command.make(
         });
       }
       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 } : {}),
@@ -171,7 +171,7 @@ const feedsCommand = Command.make(
       const appConfig = yield* AppConfigService;
       const queryValue = yield* requireNonEmptyQuery(query);
       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 } : {})
@@ -220,8 +220,7 @@ const postsCommand = Command.make(
     Effect.gen(function* () {
       const appConfig = yield* AppConfigService;
       const queryValue = yield* requireNonEmptyQuery(query);
-      const parsedLimit = yield* parseLimit(limit);
-      const limitValue = Option.getOrUndefined(parsedLimit);
+      const limitValue = Option.getOrUndefined(limit);
       if (network && Option.isSome(store)) {
         return yield* CliInputError.make({
           message: "--store cannot be used with --network.",
@@ -287,24 +286,8 @@ const postsCommand = Command.make(
               .map((item) => item.trim())
               .filter((item) => item.length > 0)
         });
-        const authorValue = Option.match(author, {
-          onNone: () => Effect.void.pipe(Effect.as(undefined)),
-          onSome: (value) =>
-            Effect.gen(function* () {
-              const decoded = yield* decodeActor(value);
-              return String(decoded);
-            })
-        });
-        const mentionsValue = Option.match(mentions, {
-          onNone: () => Effect.void.pipe(Effect.as(undefined)),
-          onSome: (value) =>
-            Effect.gen(function* () {
-              const decoded = yield* decodeActor(value);
-              return String(decoded);
-            })
-        });
-      const parsedAuthor = yield* authorValue;
-      const parsedMentions = yield* mentionsValue;
+        const parsedAuthor = Option.getOrUndefined(author);
+        const parsedMentions = Option.getOrUndefined(mentions);
       const result = yield* client.searchPosts(queryValue, {
         ...(limitValue !== undefined ? { limit: limitValue } : {}),
         ...(Option.isSome(cursorValue) ? { cursor: cursorValue.value } : {}),

package/src/cli/shared-options.ts

@@ -1,9 +1,10 @@
 import { Args, Options } from "@effect/cli";
-import { Effect, Option, Schema } from "effect";
-import { Did, Handle, StoreName } from "../domain/primitives.js";
+import { Effect, Schema } from "effect";
+import { ActorId, AtUri, PostUri, StoreName } from "../domain/primitives.js";
 import { filterDslDescription, filterJsonDescription } from "./filter-help.js";
 import { CliInputError } from "./errors.js";
 import { formatSchemaError } from "./shared.js";
+import { NonNegativeInt } from "./option-schemas.js";
 
 /** --store option with StoreName schema validation */
 export const storeNameOption = Options.text("store").pipe(
@@ -52,27 +53,32 @@ export const strictOption = Options.boolean("strict").pipe(
 
 /** --max-errors option (optional) */
 export const maxErrorsOption = Options.integer("max-errors").pipe(
+  Options.withSchema(NonNegativeInt),
   Options.withDescription("Stop after exceeding N errors (default: unlimited)"),
   Options.optional
 );
 
 /** Positional arg for feed URI */
 export const feedUriArg = Args.text({ name: "uri" }).pipe(
+  Args.withSchema(AtUri),
   Args.withDescription("Bluesky feed URI (at://...)")
 );
 
 /** Positional arg for list URI */
 export const listUriArg = Args.text({ name: "uri" }).pipe(
+  Args.withSchema(AtUri),
   Args.withDescription("Bluesky list URI (at://...)")
 );
 
 /** Positional arg for author handle or DID */
 export const actorArg = Args.text({ name: "actor" }).pipe(
+  Args.withSchema(ActorId),
   Args.withDescription("Bluesky handle or DID")
 );
 
 /** Positional arg for post URI */
 export const postUriArg = Args.text({ name: "uri" }).pipe(
+  Args.withSchema(PostUri),
   Args.withDescription("Bluesky post URI (at://...)")
 );
 
@@ -100,70 +106,12 @@ export const includePinsOption = Options.boolean("include-pins").pipe(
 );
 
 /** Validate --max-errors value is non-negative */
-export const parseMaxErrors = (maxErrors: Option.Option<number>) =>
-  Option.match(maxErrors, {
-    onNone: () => Effect.succeed(Option.none()),
-    onSome: (value) =>
-      value < 0
-        ? Effect.fail(
-            CliInputError.make({
-              message: "max-errors must be a non-negative integer.",
-              cause: value
-            })
-          )
-        : Effect.succeed(Option.some(value))
-  });
-
-export const decodeActor = (actor: string) => {
-  if (actor.startsWith("did:")) {
-    return Schema.decodeUnknown(Did)(actor).pipe(
-      Effect.mapError((error) =>
-        CliInputError.make({
-          message: `Invalid DID: ${formatSchemaError(error)}`,
-          cause: { actor }
-        })
-      )
-    );
-  }
-  return Schema.decodeUnknown(Handle)(actor).pipe(
+export const decodeActor = (actor: string) =>
+  Schema.decodeUnknown(ActorId)(actor).pipe(
     Effect.mapError((error) =>
       CliInputError.make({
-        message: `Invalid handle: ${formatSchemaError(error)}`,
+        message: `Invalid actor: ${formatSchemaError(error)}`,
         cause: { actor }
       })
     )
   );
-};
-
-export const parseLimit = (limit: Option.Option<number>) =>
-  Option.match(limit, {
-    onNone: () => Effect.succeed(Option.none()),
-    onSome: (value) =>
-      value <= 0
-        ? Effect.fail(
-            CliInputError.make({
-              message: "--limit must be a positive integer.",
-              cause: value
-            })
-          )
-        : Effect.succeed(Option.some(value))
-  });
-
-export const parseBoundedIntOption = (
-  value: Option.Option<number>,
-  name: string,
-  min: number,
-  max: number
-) =>
-  Option.match(value, {
-    onNone: () => Effect.succeed(Option.none()),
-    onSome: (raw) =>
-      raw < min || raw > max
-        ? Effect.fail(
-            CliInputError.make({
-              message: `${name} must be between ${min} and ${max}.`,
-              cause: raw
-            })
-          )
-        : Effect.succeed(Option.some(raw))
-  });

package/src/cli/shared.ts

@@ -1 +1 @@
-export { formatSchemaError } from "../services/shared.js";
+export { formatParseError, formatSchemaError } from "../services/shared.js";

package/src/cli/store-errors.ts

@@ -1,5 +1,5 @@
 import { ParseResult } from "effect";
-import { safeParseJson, issueDetails } from "./parse-errors.js";
+import { safeParseJson, issueDetails, findJsonParseIssue, jsonParseTip } from "./parse-errors.js";
 import { formatAgentError } from "./errors.js";
 
 const storeConfigExample = {
@@ -35,20 +35,16 @@ export const formatStoreConfigParseError = (
   const received = safeParseJson(raw);
   const receivedValue = received === undefined ? raw : received;
 
-  const jsonParseIssue = issues.find(
-    (issue) =>
-      issue._tag === "Transformation" &&
-      typeof issue.message === "string" &&
-      issue.message.startsWith("JSON Parse error")
-  );
+  const jsonParseIssue = findJsonParseIssue(issues);
   if (jsonParseIssue) {
+    const jsonMessage = jsonParseIssue.message ?? "Invalid JSON input.";
     return formatAgentError({
       error: "StoreConfigJsonParseError",
       message: `Invalid JSON in --config-json. ${storeConfigDocHint}`,
       received: raw,
       details: [
-        jsonParseIssue.message,
-        "Tip: wrap JSON in single quotes to avoid shell escaping issues."
+        jsonMessage,
+        jsonParseTip
       ],
       expected: storeConfigExample
     });

package/src/cli/store.ts

@@ -21,6 +21,7 @@ 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,
@@ -62,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
 );
@@ -248,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

package/src/cli/sync-factory.ts

@@ -1,4 +1,4 @@
-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";
@@ -10,7 +10,6 @@ import { CliOutput, writeJson, writeJsonStream } from "./output.js";
 import { storeOptions } from "./store.js";
 import { logInfo, logWarn, makeSyncReporter } from "./logging.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 */
@@ -20,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). */
@@ -47,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))
         );
@@ -66,9 +70,9 @@ export const makeSyncCommandBody = (
 
 /** 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<string>;
+  readonly until: Option.Option<Duration.Duration>;
 }
 
 /** Build the command body for a watch command (timeline, feed, notifications). */
@@ -87,20 +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 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))
-      });
+      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.", {
@@ -122,8 +114,8 @@ 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(input.maxCycles)) {
+        stream = stream.pipe(Stream.take(input.maxCycles.value));
       }
       if (Option.isSome(parsedUntil)) {
         stream = stream.pipe(Stream.interruptWhen(Effect.sleep(parsedUntil.value)));