@mepuka/skygent 0.2.0

package/src/cli/layers.ts

@@ -0,0 +1,180 @@
+import * as KeyValueStore from "@effect/platform/KeyValueStore";
+import { Path } from "@effect/platform";
+import * as FetchHttpClient from "@effect/platform/FetchHttpClient";
+import { Effect, Layer } from "effect";
+import { BskyClient } from "../services/bsky-client.js";
+import { FilterRuntime } from "../services/filter-runtime.js";
+import { PostParser } from "../services/post-parser.js";
+import { AppConfigService } from "../services/app-config.js";
+import { CredentialStore } from "../services/credential-store.js";
+import { StoreEventLog } from "../services/store-event-log.js";
+import { StoreIndex } from "../services/store-index.js";
+import { StoreDb } from "../services/store-db.js";
+import { StoreManager } from "../services/store-manager.js";
+import { StoreWriter } from "../services/store-writer.js";
+import { StoreCommitter } from "../services/store-commit.js";
+import { SyncEngine } from "../services/sync-engine.js";
+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 { 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 { DerivationEngine } from "../services/derivation-engine.js";
+import { DerivationValidator } from "../services/derivation-validator.js";
+import { DerivationSettings } from "../services/derivation-settings.js";
+import { ViewCheckpointStore } from "../services/view-checkpoint-store.js";
+import { LineageStore } from "../services/lineage-store.js";
+import { FilterCompiler } from "../services/filter-compiler.js";
+import { FilterSettings } from "../services/filter-settings.js";
+import { OutputManager } from "../services/output-manager.js";
+import { FilterLibrary } from "../services/filter-library.js";
+import { StoreStats } from "../services/store-stats.js";
+import { ProfileResolver } from "../services/profile-resolver.js";
+import { IdentityResolver } from "../services/identity-resolver.js";
+
+const appConfigLayer = AppConfigService.layer;
+const credentialLayer = CredentialStore.layer.pipe(Layer.provideMerge(appConfigLayer));
+const bskyLayer = BskyClient.layer.pipe(
+  Layer.provideMerge(appConfigLayer),
+  Layer.provideMerge(credentialLayer)
+);
+
+const storageLayer = Layer.unwrapEffect(
+  Effect.gen(function* () {
+    const config = yield* AppConfigService;
+    const path = yield* Path.Path;
+    const kvRoot = path.join(config.storeRoot, "kv");
+    return KeyValueStore.layerFileSystem(kvRoot);
+  })
+).pipe(Layer.provide(appConfigLayer));
+const storeDbLayer = StoreDb.layer.pipe(Layer.provideMerge(appConfigLayer));
+const writerLayer = StoreWriter.layer.pipe(Layer.provideMerge(storeDbLayer));
+const committerLayer = StoreCommitter.layer.pipe(
+  Layer.provideMerge(storeDbLayer),
+  Layer.provideMerge(writerLayer)
+);
+const eventLogLayer = StoreEventLog.layer.pipe(Layer.provideMerge(storeDbLayer));
+const indexLayer = StoreIndex.layer.pipe(
+  Layer.provideMerge(storeDbLayer),
+  Layer.provideMerge(eventLogLayer)
+);
+const managerLayer = StoreManager.layer.pipe(Layer.provideMerge(appConfigLayer));
+const cleanerLayer = StoreCleaner.layer.pipe(
+  Layer.provideMerge(managerLayer),
+  Layer.provideMerge(indexLayer),
+  Layer.provideMerge(eventLogLayer),
+  Layer.provideMerge(storeDbLayer)
+);
+const checkpointLayer = SyncCheckpointStore.layer.pipe(
+  Layer.provideMerge(storeDbLayer)
+);
+const linkValidatorLayer = LinkValidator.layer.pipe(
+  Layer.provideMerge(storageLayer),
+  Layer.provideMerge(FetchHttpClient.layer)
+);
+const trendingTopicsLayer = TrendingTopics.layer.pipe(
+  Layer.provideMerge(storageLayer),
+  Layer.provideMerge(bskyLayer)
+);
+const resourceMonitorLayer = ResourceMonitor.layer.pipe(
+  Layer.provideMerge(appConfigLayer)
+);
+const filterSettingsLayer = FilterSettings.layer;
+const runtimeLayer = FilterRuntime.layer.pipe(
+  Layer.provideMerge(filterSettingsLayer),
+  Layer.provideMerge(linkValidatorLayer),
+  Layer.provideMerge(trendingTopicsLayer)
+);
+const syncSettingsLayer = SyncSettings.layer;
+const syncLayer = SyncEngine.layer.pipe(
+  Layer.provideMerge(committerLayer),
+  Layer.provideMerge(indexLayer),
+  Layer.provideMerge(checkpointLayer),
+  Layer.provideMerge(runtimeLayer),
+  Layer.provideMerge(PostParser.layer),
+  Layer.provideMerge(bskyLayer),
+  Layer.provideMerge(SyncReporter.layer),
+  Layer.provideMerge(syncSettingsLayer)
+);
+const identityResolverLayer = IdentityResolver.layer.pipe(
+  Layer.provideMerge(storageLayer),
+  Layer.provideMerge(bskyLayer)
+);
+const profileResolverLayer = ProfileResolver.layer.pipe(
+  Layer.provideMerge(bskyLayer),
+  Layer.provideMerge(identityResolverLayer)
+);
+const viewCheckpointLayer = ViewCheckpointStore.layer.pipe(
+  Layer.provideMerge(storeDbLayer),
+  Layer.provideMerge(managerLayer)
+);
+const lineageLayer = LineageStore.layer.pipe(
+  Layer.provideMerge(storageLayer)
+);
+const compilerLayer = FilterCompiler.layer;
+const postParserLayer = PostParser.layer;
+const derivationEngineLayer = DerivationEngine.layer.pipe(
+  Layer.provideMerge(eventLogLayer),
+  Layer.provideMerge(committerLayer),
+  Layer.provideMerge(indexLayer),
+  Layer.provideMerge(compilerLayer),
+  Layer.provideMerge(runtimeLayer),
+  Layer.provideMerge(viewCheckpointLayer),
+  Layer.provideMerge(lineageLayer),
+  Layer.provideMerge(DerivationSettings.layer)
+);
+const derivationValidatorLayer = DerivationValidator.layer.pipe(
+  Layer.provideMerge(viewCheckpointLayer),
+  Layer.provideMerge(eventLogLayer),
+  Layer.provideMerge(managerLayer)
+);
+const outputManagerLayer = OutputManager.layer.pipe(
+  Layer.provideMerge(appConfigLayer),
+  Layer.provideMerge(managerLayer),
+  Layer.provideMerge(indexLayer),
+  Layer.provideMerge(runtimeLayer),
+  Layer.provideMerge(filterSettingsLayer),
+  Layer.provideMerge(compilerLayer)
+);
+const filterLibraryLayer = FilterLibrary.layer.pipe(
+  Layer.provideMerge(appConfigLayer)
+);
+const storeStatsLayer = StoreStats.layer.pipe(
+  Layer.provideMerge(appConfigLayer),
+  Layer.provideMerge(managerLayer),
+  Layer.provideMerge(indexLayer),
+  Layer.provideMerge(storeDbLayer),
+  Layer.provideMerge(lineageLayer),
+  Layer.provideMerge(derivationValidatorLayer),
+  Layer.provideMerge(eventLogLayer),
+  Layer.provideMerge(checkpointLayer)
+);
+
+export const CliLive = Layer.mergeAll(
+  appConfigLayer,
+  filterSettingsLayer,
+  credentialLayer,
+  CliOutput.layer,
+  resourceMonitorLayer,
+  managerLayer,
+  committerLayer,
+  indexLayer,
+  eventLogLayer,
+  cleanerLayer,
+  syncLayer,
+  checkpointLayer,
+  viewCheckpointLayer,
+  derivationEngineLayer,
+  derivationValidatorLayer,
+  lineageLayer,
+  outputManagerLayer,
+  storeStatsLayer,
+  compilerLayer,
+  postParserLayer,
+  filterLibraryLayer,
+  profileResolverLayer,
+  identityResolverLayer
+);

package/src/cli/logging.ts

@@ -0,0 +1,136 @@
+import { Terminal } from "@effect/platform";
+import { Effect, Option } from "effect";
+import { SyncProgress } from "../domain/sync.js";
+import { SyncReporter } from "../services/sync-reporter.js";
+import type { ResourceMonitorService, ResourceWarning } from "../services/resource-monitor.js";
+import type { CliOutputService } from "./output.js";
+import { CliOutput } from "./output.js";
+import { CliPreferences } from "./preferences.js";
+
+type LogLevel = "INFO" | "WARN" | "ERROR" | "PROGRESS";
+export type LogFormat = "json" | "human";
+
+const nowIso = () => new Date().toISOString();
+
+const encodeLog = (level: LogLevel, payload: Record<string, unknown>) =>
+  JSON.stringify({
+    timestamp: nowIso(),
+    level,
+    ...payload
+  });
+
+const formatHuman = (level: LogLevel, payload: Record<string, unknown>) => {
+  if (level === "PROGRESS" && "progress" in payload) {
+    const progress = payload.progress as SyncProgress;
+    const rate = Number.isFinite(progress.rate)
+      ? progress.rate.toFixed(2)
+      : String(progress.rate);
+    return `[PROGRESS] processed=${progress.processed} stored=${progress.stored} skipped=${progress.skipped} errors=${progress.errors} rate=${rate}/s elapsedMs=${progress.elapsedMs}`;
+  }
+
+  const message =
+    typeof payload.message === "string" && payload.message.length > 0
+      ? payload.message
+      : "";
+  const rest = { ...payload };
+  delete rest.message;
+  const suffix = Object.keys(rest).length > 0 ? ` ${JSON.stringify(rest)}` : "";
+  const base = `[${level}]${message ? ` ${message}` : ""}`;
+  return `${base}${suffix}`.trim();
+};
+
+const encodeLogFormat = (
+  format: LogFormat,
+  level: LogLevel,
+  payload: Record<string, unknown>
+) => (format === "human" ? formatHuman(level, payload) : encodeLog(level, payload));
+
+const resolveLogFormat = Effect.gen(function* () {
+  const preferences = yield* Effect.serviceOption(CliPreferences);
+  const override = Option.flatMap(preferences, (value) =>
+    Option.fromNullable(value.logFormat)
+  );
+  if (Option.isSome(override)) {
+    return override.value;
+  }
+  const terminal = yield* Effect.serviceOption(Terminal.Terminal);
+  if (Option.isSome(terminal)) {
+    const isTTY = yield* terminal.value.isTTY.pipe(Effect.orElseSucceed(() => false));
+    return isTTY ? "human" : "json";
+  }
+  return "json" as const;
+});
+
+const logEventWith = (
+  output: CliOutputService,
+  format: LogFormat,
+  level: LogLevel,
+  payload: Record<string, unknown>
+) => output.writeStderr(encodeLogFormat(format, level, payload));
+
+const logEvent = (level: LogLevel, payload: Record<string, unknown>) =>
+  Effect.gen(function* () {
+    const output = yield* CliOutput;
+    const format = yield* resolveLogFormat;
+    yield* logEventWith(output, format, level, payload);
+  });
+
+export const logInfo = (message: string, data?: Record<string, unknown>) =>
+  logEvent("INFO", { message, ...data });
+
+export const logErrorEvent = (message: string, data?: Record<string, unknown>) =>
+  logEvent("ERROR", { message, ...data });
+
+export const logWarn = (message: string, data?: Record<string, unknown>) =>
+  logEvent("WARN", { message, ...data });
+
+export const logProgress = (progress: SyncProgress) =>
+  logEvent("PROGRESS", { operation: "sync", progress });
+
+const warningDetails = (warning: ResourceWarning): Record<string, unknown> => {
+  switch (warning._tag) {
+    case "StoreSize":
+      return {
+        kind: warning._tag,
+        bytes: warning.bytes,
+        threshold: warning.threshold,
+        root: warning.root
+      };
+    case "MemoryRss":
+      return {
+        kind: warning._tag,
+        bytes: warning.bytes,
+        threshold: warning.threshold
+      };
+  }
+};
+
+export const makeSyncReporter = (
+  quiet: boolean,
+  monitor: ResourceMonitorService,
+  output: CliOutputService
+) =>
+  SyncReporter.of({
+    report: (progress) =>
+      Effect.gen(function* () {
+        const format = yield* resolveLogFormat;
+        if (!quiet) {
+          yield* logEventWith(output, format, "PROGRESS", {
+            operation: "sync",
+            progress
+          });
+        }
+        const warnings = yield* monitor.check();
+        if (warnings.length > 0) {
+          yield* Effect.forEach(
+            warnings,
+            (warning) =>
+              logEventWith(output, format, "WARN", {
+                message: "Resource warning",
+                ...warningDetails(warning)
+              }),
+            { discard: true }
+          );
+        }
+      }).pipe(Effect.orElseSucceed(() => undefined))
+  });

package/src/cli/output-format.ts

@@ -0,0 +1,26 @@
+import { Option } from "effect";
+import type { OutputFormat } from "../domain/config.js";
+
+export const jsonNdjsonTableFormats = ["json", "ndjson", "table"] as const;
+export type JsonNdjsonTableFormat = typeof jsonNdjsonTableFormats[number];
+
+export const jsonTableFormats = ["json", "table"] as const;
+export type JsonTableFormat = typeof jsonTableFormats[number];
+
+export const textJsonFormats = ["text", "json"] as const;
+export type TextJsonFormat = typeof textJsonFormats[number];
+
+export const treeTableJsonFormats = ["tree", "table", "json"] as const;
+export type TreeTableJsonFormat = typeof treeTableJsonFormats[number];
+
+export const resolveOutputFormat = <T extends string>(
+  format: Option.Option<T>,
+  configFormat: OutputFormat,
+  supported: readonly T[],
+  fallback: T
+) => {
+  if (Option.isSome(format)) {
+    return format.value;
+  }
+  return supported.includes(configFormat as T) ? (configFormat as T) : fallback;
+};

package/src/cli/output.ts

@@ -0,0 +1,82 @@
+import { BunSink } from "@effect/platform-bun";
+import { SystemError, type PlatformError } from "@effect/platform/Error";
+import { Context, Effect, Layer, Sink, Stream } from "effect";
+
+const jsonLine = (value: unknown, pretty?: boolean) =>
+  JSON.stringify(value, null, pretty ? 2 : 0);
+
+const ensureNewline = (value: string) => (value.endsWith("\n") ? value : `${value}\n`);
+
+const writeToSink = (
+  sink: Sink.Sink<void, string | Uint8Array, never, PlatformError>,
+  value: string
+) => Stream.fromIterable([value]).pipe(Stream.run(sink));
+
+export interface CliOutputService {
+  readonly stdout: Sink.Sink<void, string | Uint8Array, never, PlatformError>;
+  readonly stderr: Sink.Sink<void, string | Uint8Array, never, PlatformError>;
+  readonly writeJson: (value: unknown, pretty?: boolean) => Effect.Effect<void, PlatformError>;
+  readonly writeText: (value: string) => Effect.Effect<void, PlatformError>;
+  readonly writeJsonStream: <A, E, R>(
+    stream: Stream.Stream<A, E, R>
+  ) => Effect.Effect<void, E | PlatformError, R>;
+  readonly writeStderr: (value: string) => Effect.Effect<void, PlatformError>;
+}
+
+export class CliOutput extends Context.Tag("@skygent/CliOutput")<
+  CliOutput,
+  CliOutputService
+>() {
+  static readonly layer = Layer.succeed(
+    CliOutput,
+    (() => {
+      const stdout = BunSink.fromWritable(
+        () => process.stdout,
+        (cause) =>
+          new SystemError({
+            module: "Stream",
+            method: "stdout",
+            reason: "Unknown",
+            cause
+          }),
+        { endOnDone: false }
+      );
+      const stderr = BunSink.fromWritable(
+        () => process.stderr,
+        (cause) =>
+          new SystemError({
+            module: "Stream",
+            method: "stderr",
+            reason: "Unknown",
+            cause
+          }),
+        { endOnDone: false }
+      );
+
+      return CliOutput.of({
+        stdout,
+        stderr,
+        writeJson: (value, pretty) =>
+          writeToSink(stdout, ensureNewline(jsonLine(value, pretty))),
+        writeText: (value) => writeToSink(stdout, ensureNewline(value)),
+        writeJsonStream: (stream) =>
+          stream.pipe(
+            Stream.map((value) => `${jsonLine(value)}\n`),
+            Stream.run(stdout)
+          ),
+        writeStderr: (value) => writeToSink(stderr, ensureNewline(value))
+      });
+    })()
+  );
+}
+
+export const writeJson = (value: unknown, pretty?: boolean) =>
+  Effect.flatMap(CliOutput, (output) => output.writeJson(value, pretty));
+
+export const writeText = (value: string) =>
+  Effect.flatMap(CliOutput, (output) => output.writeText(value));
+
+export const writeJsonStream = <A, E, R>(
+  stream: Stream.Stream<A, E, R>
+): Effect.Effect<void, E | PlatformError, R | CliOutput> =>
+  Effect.flatMap(CliOutput, (output) => output.writeJsonStream(stream));

package/src/cli/parse.ts

@@ -0,0 +1,80 @@
+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");
+};
+
+type DecodeJsonOptions = {
+  readonly formatter?: (error: ParseResult.ParseError, raw: string) => string;
+  readonly label?: string;
+  readonly maxIssues?: number;
+};
+
+export const decodeJson = <A, I, R>(
+  schema: Schema.Schema<A, I, R>,
+  input: string,
+  options?: DecodeJsonOptions
+) =>
+  Schema.decodeUnknown(Schema.parseJson(schema))(input).pipe(
+    Effect.mapError((error) => {
+      const formatOptions =
+        options?.label !== undefined || options?.maxIssues !== undefined
+          ? {
+              ...(options?.label !== undefined ? { label: options.label } : {}),
+              ...(options?.maxIssues !== undefined
+                ? { maxIssues: options.maxIssues }
+                : {})
+            }
+          : undefined;
+      const message = ParseResult.isParseError(error)
+        ? options?.formatter
+          ? options.formatter(error, input)
+          : formatParseError(error, formatOptions)
+        : String(error);
+      return CliJsonError.make({ message, cause: error });
+    })
+  );

package/src/cli/post.ts

@@ -0,0 +1,193 @@
+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 { 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 { writeJson, writeJsonStream, writeText } from "./output.js";
+import { renderTableLegacy } from "./doc/table.js";
+import { jsonNdjsonTableFormats, resolveOutputFormat } from "./output-format.js";
+
+const limitOption = Options.integer("limit").pipe(
+  Options.withDescription("Maximum number of results"),
+  Options.optional
+);
+
+const cursorOption = Options.text("cursor").pipe(
+  Options.withDescription("Pagination cursor"),
+  Options.optional
+);
+
+const formatOption = Options.choice("format", jsonNdjsonTableFormats).pipe(
+  Options.withDescription("Output format (default: json)"),
+  Options.optional
+);
+
+const cidOption = Options.text("cid").pipe(
+  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) => [
+    like.actor.handle,
+    like.actor.displayName ?? "",
+    like.actor.did,
+    like.createdAt.toISOString(),
+    like.indexedAt.toISOString()
+  ]);
+  const table = renderTableLegacy(
+    ["HANDLE", "DISPLAY NAME", "DID", "CREATED AT", "INDEXED AT"],
+    rows
+  );
+  return cursor ? `${table}\n\nCursor: ${cursor}` : table;
+};
+
+type PostParserService = Context.Tag.Service<typeof PostParser>;
+
+const parseRawPosts = (parser: PostParserService, posts: ReadonlyArray<RawPost>) =>
+  Effect.forEach(posts, (raw) => parser.parsePost(raw), { concurrency: "unbounded" });
+
+const likesCommand = Command.make(
+  "likes",
+  { uri: postUriArg, cid: cidOption, limit: limitOption, cursor: cursorOption, format: formatOption },
+  ({ uri, cid, limit, cursor, format }) =>
+    Effect.gen(function* () {
+      const appConfig = yield* AppConfigService;
+      const client = yield* BskyClient;
+      const parsedLimit = yield* parseLimit(limit);
+      const result = yield* client.getLikes(uri, {
+        ...(Option.isSome(parsedLimit) ? { limit: parsedLimit.value } : {}),
+        ...(Option.isSome(cursor) ? { cursor: cursor.value } : {}),
+        ...(Option.isSome(cid) ? { cid: cid.value } : {})
+      });
+      const outputFormat = resolveOutputFormat(
+        format,
+        appConfig.outputFormat,
+        jsonNdjsonTableFormats,
+        "json"
+      );
+      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(
+    withExamples("List accounts that liked a post", [
+      "skygent post likes at://did:plc:example/app.bsky.feed.post/xyz",
+      "skygent post likes at://did:plc:example/app.bsky.feed.post/xyz --limit 50"
+    ])
+  )
+);
+
+const repostedByCommand = Command.make(
+  "reposted-by",
+  { uri: postUriArg, cid: cidOption, limit: limitOption, cursor: cursorOption, format: formatOption },
+  ({ uri, cid, limit, cursor, format }) =>
+    Effect.gen(function* () {
+      const appConfig = yield* AppConfigService;
+      const client = yield* BskyClient;
+      const parsedLimit = yield* parseLimit(limit);
+      const result = yield* client.getRepostedBy(uri, {
+        ...(Option.isSome(parsedLimit) ? { limit: parsedLimit.value } : {}),
+        ...(Option.isSome(cursor) ? { cursor: cursor.value } : {}),
+        ...(Option.isSome(cid) ? { cid: cid.value } : {})
+      });
+      const outputFormat = resolveOutputFormat(
+        format,
+        appConfig.outputFormat,
+        jsonNdjsonTableFormats,
+        "json"
+      );
+      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(
+    withExamples("List accounts that reposted a post", [
+      "skygent post reposted-by at://did:plc:example/app.bsky.feed.post/xyz"
+    ])
+  )
+);
+
+const quotesCommand = Command.make(
+  "quotes",
+  { uri: postUriArg, cid: cidOption, limit: limitOption, cursor: cursorOption, format: formatOption },
+  ({ uri, cid, limit, cursor, format }) =>
+    Effect.gen(function* () {
+      const appConfig = yield* AppConfigService;
+      const client = yield* BskyClient;
+      const parser = yield* PostParser;
+      const parsedLimit = yield* parseLimit(limit);
+      const result = yield* client.getQuotes(uri, {
+        ...(Option.isSome(parsedLimit) ? { limit: parsedLimit.value } : {}),
+        ...(Option.isSome(cursor) ? { cursor: cursor.value } : {}),
+        ...(Option.isSome(cid) ? { cid: cid.value } : {})
+      });
+      const posts = yield* parseRawPosts(parser, result.posts);
+      const outputFormat = resolveOutputFormat(
+        format,
+        appConfig.outputFormat,
+        jsonNdjsonTableFormats,
+        "json"
+      );
+      if (outputFormat === "ndjson") {
+        yield* writeJsonStream(Stream.fromIterable(posts));
+        return;
+      }
+      if (outputFormat === "table") {
+        yield* writeText(renderPostsTable(posts));
+        return;
+      }
+      yield* writeJson({
+        ...result,
+        posts
+      });
+    })
+).pipe(
+  Command.withDescription(
+    withExamples("List quote-posts for a post", [
+      "skygent post quotes at://did:plc:example/app.bsky.feed.post/xyz"
+    ])
+  )
+);
+
+export const postCommand = Command.make("post", {}).pipe(
+  Command.withSubcommands([likesCommand, repostedByCommand, quotesCommand]),
+  Command.withDescription(
+    withExamples("Inspect post engagement", [
+      "skygent post likes at://did:plc:example/app.bsky.feed.post/xyz",
+      "skygent post quotes at://did:plc:example/app.bsky.feed.post/xyz"
+    ])
+  )
+);