grokbox 0.0.1 → 0.1.0-alpha.0

package/src/commands/memory.ts

@@ -1,47 +0,0 @@
-import type { CliDeps } from "../deps.ts";
-import { usage } from "../errors.ts";
-import { GatewayClient, gatewayMeta } from "../gateway.ts";
-import { writeSuccess } from "../output.ts";
-import { ioFromOpts } from "../opts.ts";
-import { projectMemory } from "../redaction.ts";
-import { MEMORY_UPSTREAM_CAP } from "../registry.ts";
-import { parseInteger } from "../util.ts";
-
-export async function runMemoryList(
-  deps: CliDeps,
-  raw: {
-    json?: boolean;
-    table?: boolean;
-    timeoutMs?: string;
-    agent?: string;
-    limit?: string;
-    content?: boolean;
-  },
-): Promise<void> {
-  const io = ioFromOpts(raw);
-  const includeContent = Boolean(raw.content);
-  if (io.table) throw usage("memory list does not support --table.");
-  const agentId = raw.agent;
-  if (!agentId) throw usage("--agent is required.");
-  const limit = parseInteger(raw.limit, {
-    name: "--limit",
-    min: 1,
-    max: MEMORY_UPSTREAM_CAP,
-    defaultValue: 100,
-  });
-  const client = new GatewayClient(deps);
-  const { result, discovery } = await client.getAgentMemories(agentId, io.timeoutMs);
-  const source = Array.isArray(result) ? result : [];
-  const sliced = source.slice(0, limit);
-  writeSuccess(
-    deps.stdout,
-    {
-      agentId,
-      returned: sliced.length,
-      sourceCount: source.length,
-      sourceMayBeTruncated: source.length === MEMORY_UPSTREAM_CAP,
-      memories: sliced.map((row) => projectMemory(row, includeContent)),
-    },
-    gatewayMeta(discovery),
-  );
-}

package/src/commands/roster.ts

@@ -1,11 +0,0 @@
-import { CliError, usage } from "../errors.ts";
-import { isRecord } from "../util.ts";
-
-export function findRosterRow(agents: unknown[], id: string): Record<string, unknown> {
-  if (id.length === 0) throw usage("Agent id is required.");
-  const row = agents.find((item): item is Record<string, unknown> => isRecord(item) && item.id === id);
-  if (!row) {
-    throw new CliError("target_not_found", "No roster row matched that id.");
-  }
-  return row;
-}

package/src/commands/send.ts

@@ -1,72 +0,0 @@
-import type { CliDeps } from "../deps.ts";
-import { CliError, usage } from "../errors.ts";
-import { GatewayClient, gatewayMeta } from "../gateway.ts";
-import { writeSuccess } from "../output.ts";
-import { ioFromOpts, readPrompt } from "../opts.ts";
-import { agentKind } from "../redaction.ts";
-import { assertUuidV4, isRecord } from "../util.ts";
-import { findRosterRow } from "./roster.ts";
-
-export async function runSend(
-  deps: CliDeps,
-  raw: {
-    json?: boolean;
-    table?: boolean;
-    timeoutMs?: string;
-    agent?: string;
-    group?: string;
-    text?: string;
-    nonce?: string;
-  },
-): Promise<void> {
-  const io = ioFromOpts(raw);
-  if (io.table) throw usage("This command does not support --table.");
-  const agentId = raw.agent;
-  const groupId = raw.group;
-  if ((agentId === undefined) === (groupId === undefined)) {
-    throw usage("Provide exactly one of --agent or --group.");
-  }
-  const wantedKind = agentId !== undefined ? "agent" : "group";
-  const targetId = (agentId ?? groupId) as string;
-  const prompt = await readPrompt(raw.text, deps);
-  const clientNonce = raw.nonce === undefined ? deps.randomUUID() : assertUuidV4(raw.nonce, "--nonce");
-  const client = new GatewayClient(deps);
-  const { agents } = await client.listAgents(io.timeoutMs);
-  const row = findRosterRow(agents, targetId);
-  const actualKind = agentKind(row);
-  if (actualKind !== wantedKind) {
-    throw new CliError(
-      "target_kind_mismatch",
-      wantedKind === "agent"
-        ? "--agent matched a group id."
-        : "--group matched a non-group agent id.",
-    );
-  }
-  try {
-    const { result, discovery } = await client.sendPrompt(
-      { agentId: String(row.id), prompt, clientNonce },
-      io.timeoutMs,
-    );
-    const accepted = !isRecord(result) || result.accepted !== false;
-    if (!accepted) {
-      throw new CliError("gateway_internal", "Gateway did not accept the send.");
-    }
-    writeSuccess(
-      deps.stdout,
-      {
-        status: "accepted",
-        accepted: true,
-        target: { id: String(row.id), kind: actualKind },
-        clientNonce,
-      },
-      gatewayMeta(discovery),
-    );
-  } catch (error) {
-    if (error instanceof CliError && error.code === "send_delivery_unknown") {
-      throw new CliError("send_delivery_unknown", error.message, {
-        context: { clientNonce, target: { id: String(row.id), kind: actualKind } },
-      });
-    }
-    throw error;
-  }
-}

package/src/deps.ts

@@ -1,49 +0,0 @@
-import { join } from "node:path";
-import cliPackage from "../package.json" with { type: "json" };
-import { DEFAULT_DISCOVERY_PATH } from "./registry.ts";
-import type { Writable } from "./output.ts";
-
-export type FetchFn = typeof fetch;
-
-export type CliDeps = {
-  discoveryPath: string;
-  fetch: FetchFn;
-  now: () => number;
-  randomUUID: () => string;
-  readFile: (path: string) => Promise<string>;
-  stdout: Writable;
-  stderr: Writable;
-  stdinIsTTY: boolean;
-  readStdin: () => Promise<string>;
-  skillsDir: string;
-  cliVersion: string;
-  idleWatchdogMs: number;
-  signal?: AbortSignal;
-};
-
-export const CLI_VERSION: string = cliPackage.version;
-
-export function createProductionDeps(): CliDeps {
-  return {
-    discoveryPath: DEFAULT_DISCOVERY_PATH,
-    fetch: globalThis.fetch.bind(globalThis),
-    now: () => Date.now(),
-    randomUUID: () => crypto.randomUUID(),
-    readFile: async (path) => await Bun.file(path).text(),
-    stdout: {
-      write(chunk) {
-        process.stdout.write(chunk);
-      },
-    },
-    stderr: {
-      write(chunk) {
-        process.stderr.write(chunk);
-      },
-    },
-    stdinIsTTY: Boolean(process.stdin.isTTY),
-    readStdin: async () => await Bun.stdin.text(),
-    skillsDir: join(import.meta.dir, "..", "skills"),
-    cliVersion: CLI_VERSION,
-    idleWatchdogMs: 45_000,
-  };
-}

package/src/errors.ts

@@ -1,132 +0,0 @@
-export const EXIT_CODES = {
-  ok: 0,
-  invalid_usage: 2,
-  discovery_unavailable: 3,
-  gateway_unreachable: 4,
-  gateway_bad_request: 10,
-  gateway_unauthorized: 11,
-  gateway_forbidden: 12,
-  gateway_not_found: 13,
-  gateway_conflict: 14,
-  gateway_internal: 15,
-  send_delivery_unknown: 16,
-  target_not_found: 17,
-  target_kind_mismatch: 18,
-} as const;
-
-export type ErrorCode = Exclude<keyof typeof EXIT_CODES, "ok">;
-
-export type ErrorBody = {
-  code: ErrorCode;
-  message: string;
-  httpStatus?: number;
-  failureCode?: string;
-  retryable: boolean;
-  context?: {
-    clientNonce: string;
-    target: { id: string; kind: "agent" | "group" };
-  };
-};
-
-const RETRYABLE: Record<ErrorCode, boolean> = {
-  invalid_usage: false,
-  discovery_unavailable: false,
-  gateway_unreachable: true,
-  gateway_bad_request: false,
-  gateway_unauthorized: false,
-  gateway_forbidden: false,
-  gateway_not_found: false,
-  gateway_conflict: false,
-  gateway_internal: true,
-  send_delivery_unknown: false,
-  target_not_found: false,
-  target_kind_mismatch: false,
-};
-
-export class CliError extends Error {
-  readonly code: ErrorCode;
-  readonly httpStatus?: number;
-  readonly failureCode?: string;
-  readonly retryable: boolean;
-  readonly context?: ErrorBody["context"];
-
-  constructor(
-    code: ErrorCode,
-    message: string,
-    extras: {
-      httpStatus?: number;
-      failureCode?: string;
-      retryable?: boolean;
-      context?: ErrorBody["context"];
-    } = {},
-  ) {
-    super(message);
-    this.name = "CliError";
-    this.code = code;
-    this.httpStatus = extras.httpStatus;
-    this.failureCode = extras.failureCode;
-    this.retryable = extras.retryable ?? RETRYABLE[code];
-    this.context = extras.context;
-  }
-
-  get exitCode(): number {
-    return EXIT_CODES[this.code];
-  }
-
-  toErrorBody(): ErrorBody {
-    const body: ErrorBody = {
-      code: this.code,
-      message: this.message,
-      retryable: this.retryable,
-    };
-    if (this.httpStatus !== undefined) body.httpStatus = this.httpStatus;
-    if (this.failureCode !== undefined) body.failureCode = this.failureCode;
-    if (this.context !== undefined) body.context = this.context;
-    return body;
-  }
-}
-
-export function usage(message: string): CliError {
-  return new CliError("invalid_usage", message);
-}
-
-export function httpStatusToError(
-  status: number,
-  failureCode: string | undefined,
-  fallbackMessage: string,
-): CliError {
-  if (status === 400) {
-    return new CliError("gateway_bad_request", "Gateway rejected the request body.", {
-      httpStatus: 400,
-      failureCode,
-    });
-  }
-  if (status === 401) {
-    return new CliError("gateway_unauthorized", "Gateway rejected the credentials.", {
-      httpStatus: 401,
-      failureCode,
-    });
-  }
-  if (status === 403) {
-    return new CliError("gateway_forbidden", "Gateway forbade the request.", {
-      httpStatus: 403,
-      failureCode,
-    });
-  }
-  if (status === 404) {
-    return new CliError("gateway_not_found", "Gateway method or path was not found.", {
-      httpStatus: 404,
-      failureCode,
-    });
-  }
-  if (status === 409) {
-    return new CliError("gateway_conflict", "Gateway rejected the request.", {
-      httpStatus: 409,
-      failureCode,
-    });
-  }
-  return new CliError("gateway_internal", fallbackMessage, {
-    httpStatus: status,
-    failureCode,
-  });
-}