@mepuka/skygent 0.2.0

package/src/cli/doc/tree.ts

@@ -0,0 +1,126 @@
+import * as Doc from "@effect/printer/Doc";
+import type { Annotation } from "./annotation.js";
+import { connector } from "./primitives.js";
+
+type SDoc = Doc.Doc<Annotation>;
+
+export interface RenderContext<E> {
+  readonly depth: number;
+  readonly isRoot: boolean;
+  readonly isLast: boolean;
+  readonly edge?: E;
+}
+
+export interface TreeConfig<T, E = void> {
+  readonly children: (node: T) => ReadonlyArray<{ node: T; edge: E }>;
+  /** Return a single Doc (single-line) or an array of Docs (multi-line node).
+   *  First element is the headline; subsequent elements are continuation lines
+   *  that receive the content prefix (│ or spaces) without a connector. */
+  readonly renderNode: (node: T, ctx: RenderContext<E>) => SDoc | ReadonlyArray<SDoc>;
+  readonly details?: (node: T, ctx: RenderContext<E>) => ReadonlyArray<SDoc>;
+  readonly key: (node: T) => string;
+}
+
+interface WalkParams<T, E> {
+  readonly prefix: string;
+  readonly isLast: boolean;
+  readonly isRoot: boolean;
+  readonly path: ReadonlyArray<string>;
+  readonly edge: E | undefined;
+  readonly depth: number;
+  readonly docs: Array<SDoc>;
+}
+
+const walkNode = <T, E>(
+  node: T,
+  config: TreeConfig<T, E>,
+  params: WalkParams<T, E>
+): void => {
+  const { prefix, isLast, isRoot, path, edge, depth, docs } = params;
+  const key = config.key(node);
+  const ctx: RenderContext<E> = { depth, isRoot, isLast, edge: edge as E };
+
+  // 1. Headline with connector prefix (+ continuation lines for multi-line nodes)
+  const rendered = config.renderNode(node, ctx);
+  const nodeLines = Array.isArray(rendered) ? rendered : [rendered];
+  const connectorStr = isRoot ? "" : isLast ? "└── " : "├── ";
+  const contentPrefix = prefix + (isRoot ? "" : isLast ? "    " : "│   ");
+  nodeLines.forEach((line, i) => {
+    if (i === 0) {
+      docs.push(Doc.cat(connector(prefix + connectorStr), line));
+    } else {
+      docs.push(Doc.cat(connector(contentPrefix), line));
+    }
+  });
+
+  // 2. Cycle check: path-based
+  if (path.includes(key)) {
+    const nextPrefix = prefix + (isRoot ? "" : isLast ? "    " : "│   ");
+    docs.push(Doc.cat(
+      connector(nextPrefix + "└── "),
+      Doc.annotate(Doc.text("(cycle detected)"), "cycle" as Annotation)
+    ));
+    return;
+  }
+
+  // 3. Compute child prefix
+  const nextPrefix = prefix + (isRoot ? "" : isLast ? "    " : "│   ");
+  const nextPath = [...path, key];
+
+  // 4. Collect detail lines and children
+  const detailDocs = config.details?.(node, ctx) ?? [];
+  const childEntries = config.children(node);
+  const items: Array<
+    | { readonly type: "detail"; readonly doc: SDoc }
+    | { readonly type: "child"; readonly node: T; readonly edge: E }
+  > = [
+    ...detailDocs.map((d) => ({ type: "detail" as const, doc: d })),
+    ...childEntries.map((c) => ({ type: "child" as const, node: c.node, edge: c.edge }))
+  ];
+
+  // 5. Render each item with proper connectors
+  items.forEach((item, i) => {
+    const itemIsLast = i === items.length - 1;
+    if (item.type === "detail") {
+      const itemConnector = itemIsLast ? "└── " : "├── ";
+      docs.push(Doc.cat(
+        connector(nextPrefix + itemConnector),
+        item.doc
+      ));
+    } else {
+      walkNode(item.node, config, {
+        prefix: nextPrefix,
+        isLast: itemIsLast,
+        isRoot: false,
+        path: nextPath,
+        edge: item.edge,
+        depth: depth + 1,
+        docs
+      });
+    }
+  });
+};
+
+export const renderTree = <T, E = void>(
+  roots: ReadonlyArray<T>,
+  config: TreeConfig<T, E>
+): SDoc => {
+  const docs: Array<SDoc> = [];
+
+  roots.forEach((root, i) => {
+    walkNode(root, config, {
+      prefix: "",
+      isLast: i === roots.length - 1,
+      isRoot: true,
+      path: [],
+      edge: undefined,
+      depth: 0,
+      docs
+    });
+    if (i < roots.length - 1) {
+      docs.push(Doc.empty);
+    }
+  });
+
+  return Doc.vsep(docs);
+};

package/src/cli/errors.ts

@@ -0,0 +1,59 @@
+import { Schema } from "effect";
+
+export class CliJsonError extends Schema.TaggedError<CliJsonError>()(
+  "CliJsonError",
+  {
+    message: Schema.String,
+    cause: Schema.Defect
+  }
+) {}
+
+export class CliInputError extends Schema.TaggedError<CliInputError>()(
+  "CliInputError",
+  {
+    message: Schema.String,
+    cause: Schema.Defect
+  }
+) {}
+
+export type AgentErrorPayload = {
+  readonly error: string;
+  readonly message: string;
+  readonly received?: unknown;
+  readonly expected?: unknown;
+  readonly fix?: string;
+  readonly details?: ReadonlyArray<string>;
+  readonly validTags?: ReadonlyArray<string>;
+};
+
+export const formatAgentError = (payload: AgentErrorPayload) =>
+  JSON.stringify(payload, null, 2);
+
+const looksLikeJson = (value: string) => {
+  const trimmed = value.trim();
+  return trimmed.startsWith("{") || trimmed.startsWith("[");
+};
+
+const isAgentErrorPayload = (value: unknown): value is AgentErrorPayload => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (!("error" in value) || !("message" in value)) {
+    return false;
+  }
+  const error = (value as { readonly error?: unknown }).error;
+  const message = (value as { readonly message?: unknown }).message;
+  return typeof error === "string" && typeof message === "string";
+};
+
+export const parseAgentErrorPayload = (message: string): AgentErrorPayload | undefined => {
+  if (!looksLikeJson(message)) {
+    return undefined;
+  }
+  try {
+    const parsed = JSON.parse(message) as unknown;
+    return isAgentErrorPayload(parsed) ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+};

package/src/cli/exit-codes.ts

@@ -0,0 +1,52 @@
+import { ValidationError } from "@effect/cli";
+import { Cause, Exit, Option } from "effect";
+import { CliInputError, CliJsonError } from "./errors.js";
+import {
+  BskyError,
+  ConfigError,
+  FilterCompileError,
+  FilterEvalError,
+  FilterLibraryError,
+  FilterNotFound,
+  StoreIoError,
+  StoreIndexError,
+  StoreNotFound
+} from "../domain/errors.js";
+import { SyncError } from "../domain/sync.js";
+import { DerivationError } from "../domain/derivation.js";
+
+export const exitCodeFor = (error: unknown): number => {
+  if (ValidationError.isValidationError(error)) return 2;
+  if (error instanceof CliJsonError) return 2;
+  if (error instanceof CliInputError) return 2;
+  if (error instanceof ConfigError) return 2;
+  if (error instanceof StoreNotFound) return 3;
+  if (error instanceof FilterNotFound) return 2;
+  if (error instanceof FilterLibraryError) return 2;
+  if (error instanceof StoreIoError || error instanceof StoreIndexError) return 7;
+  if (error instanceof FilterCompileError || error instanceof FilterEvalError) return 8;
+  if (error instanceof DerivationError) return 2;
+  if (error instanceof SyncError) {
+    switch (error.stage) {
+      case "source":
+        return 5;
+      case "filter":
+        return 8;
+      case "store":
+        return 7;
+      default:
+        return 1;
+    }
+  }
+  if (error instanceof BskyError) return 5;
+  return 1;
+};
+
+export const exitCodeFromExit = (exit: Exit.Exit<unknown, unknown>) => {
+  if (Exit.isSuccess(exit)) return 0;
+  const failure = Cause.failureOption(exit.cause);
+  return Option.match(failure, {
+    onNone: () => 1,
+    onSome: exitCodeFor
+  });
+};

package/src/cli/feed.ts

@@ -0,0 +1,177 @@
+import { Args, Command, Options } from "@effect/cli";
+import { Effect, Option, Stream } from "effect";
+import { renderTableLegacy } from "./doc/table.js";
+import { BskyClient } from "../services/bsky-client.js";
+import type { FeedGeneratorView } from "../domain/bsky.js";
+import { AppConfigService } from "../services/app-config.js";
+import { decodeActor, parseLimit } from "./shared-options.js";
+import { CliInputError } from "./errors.js";
+import { withExamples } from "./help.js";
+import { writeJson, writeJsonStream, writeText } from "./output.js";
+import { jsonNdjsonTableFormats, resolveOutputFormat } from "./output-format.js";
+
+const feedUriArg = Args.text({ name: "uri" }).pipe(
+  Args.withDescription("Bluesky feed URI (at://...)")
+);
+
+const feedUrisArg = Args.text({ name: "uri" }).pipe(
+  Args.repeated,
+  Args.withDescription("Feed URIs to fetch")
+);
+
+const actorArg = Args.text({ name: "actor" }).pipe(
+  Args.withDescription("Bluesky handle or DID")
+);
+
+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 renderFeedTable = (
+  feeds: ReadonlyArray<FeedGeneratorView>,
+  cursor: string | undefined
+) => {
+  const rows = feeds.map((feed) => [
+    feed.displayName,
+    feed.creator.handle,
+    feed.uri,
+    typeof feed.likeCount === "number" ? String(feed.likeCount) : ""
+  ]);
+  const table = renderTableLegacy(["NAME", "CREATOR", "URI", "LIKES"], rows);
+  return cursor ? `${table}\n\nCursor: ${cursor}` : table;
+};
+
+const renderFeedInfoTable = (
+  view: FeedGeneratorView,
+  isOnline: boolean,
+  isValid: boolean
+) =>
+  renderTableLegacy(
+    ["NAME", "CREATOR", "URI", "ONLINE", "VALID"],
+    [[view.displayName, view.creator.handle, view.uri, String(isOnline), String(isValid)]]
+  );
+
+const showCommand = Command.make(
+  "show",
+  { uri: feedUriArg, format: formatOption },
+  ({ uri, format }) =>
+    Effect.gen(function* () {
+      const appConfig = yield* AppConfigService;
+      const client = yield* BskyClient;
+      const result = yield* client.getFeedGenerator(uri);
+      const outputFormat = resolveOutputFormat(
+        format,
+        appConfig.outputFormat,
+        jsonNdjsonTableFormats,
+        "json"
+      );
+      if (outputFormat === "table") {
+        yield* writeText(renderFeedInfoTable(result.view, result.isOnline, result.isValid));
+        return;
+      }
+      yield* writeJson(result);
+    })
+).pipe(
+  Command.withDescription(
+    withExamples("Show feed generator details", [
+      "skygent feed show at://did:plc:example/app.bsky.feed.generator/xyz"
+    ])
+  )
+);
+
+const batchCommand = Command.make(
+  "batch",
+  { uris: feedUrisArg, format: formatOption },
+  ({ uris, format }) =>
+    Effect.gen(function* () {
+      const appConfig = yield* AppConfigService;
+      const client = yield* BskyClient;
+      if (uris.length === 0) {
+        return yield* CliInputError.make({
+          message: "Provide at least one feed URI.",
+          cause: { uris }
+        });
+      }
+      const result = yield* client.getFeedGenerators(uris);
+      const outputFormat = resolveOutputFormat(
+        format,
+        appConfig.outputFormat,
+        jsonNdjsonTableFormats,
+        "json"
+      );
+      if (outputFormat === "ndjson") {
+        yield* writeJsonStream(Stream.fromIterable(result.feeds));
+        return;
+      }
+      if (outputFormat === "table") {
+        yield* writeText(renderFeedTable(result.feeds, undefined));
+        return;
+      }
+      yield* writeJson(result);
+    })
+).pipe(
+  Command.withDescription(
+    withExamples("Fetch multiple feed generators", [
+      "skygent feed batch at://did:plc:example/app.bsky.feed.generator/one at://did:plc:example/app.bsky.feed.generator/two"
+    ])
+  )
+);
+
+const byActorCommand = Command.make(
+  "by",
+  { actor: actorArg, limit: limitOption, cursor: cursorOption, format: formatOption },
+  ({ actor, limit, cursor, format }) =>
+    Effect.gen(function* () {
+      const appConfig = yield* AppConfigService;
+      const client = yield* BskyClient;
+      const parsedLimit = yield* parseLimit(limit);
+      const resolvedActor = yield* decodeActor(actor);
+      const result = yield* client.getActorFeeds(resolvedActor, {
+        ...(Option.isSome(parsedLimit) ? { limit: parsedLimit.value } : {}),
+        ...(Option.isSome(cursor) ? { cursor: cursor.value } : {})
+      });
+      const outputFormat = resolveOutputFormat(
+        format,
+        appConfig.outputFormat,
+        jsonNdjsonTableFormats,
+        "json"
+      );
+      if (outputFormat === "ndjson") {
+        yield* writeJsonStream(Stream.fromIterable(result.feeds));
+        return;
+      }
+      if (outputFormat === "table") {
+        yield* writeText(renderFeedTable(result.feeds, result.cursor));
+        return;
+      }
+      yield* writeJson(result);
+    })
+).pipe(
+  Command.withDescription(
+    withExamples("List feeds created by an actor", [
+      "skygent feed by alice.bsky.social",
+      "skygent feed by did:plc:example --limit 25"
+    ])
+  )
+);
+
+export const feedCommand = Command.make("feed", {}).pipe(
+  Command.withSubcommands([showCommand, batchCommand, byActorCommand]),
+  Command.withDescription(
+    withExamples("Discover feed generators", [
+      "skygent feed show at://did:plc:example/app.bsky.feed.generator/xyz",
+      "skygent feed by alice.bsky.social"
+    ])
+  )
+);