@ted-galago/wave-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1078 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { CommanderError, InvalidArgumentError } from "commander";
+import { ZodError } from "zod";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/tasks.ts
+import { z as z2 } from "zod";
+
+// src/config.ts
+import { z } from "zod";
+
+// src/errors.ts
+var EXIT_CODES = {
+  success: 0,
+  generic: 1,
+  invalidArgs: 2,
+  missingOrInvalidAuth: 3,
+  forbidden: 4,
+  notFound: 5,
+  validationFailure: 6,
+  networkOrUpstream: 7
+};
+var CliError = class extends Error {
+  kind;
+  status;
+  details;
+  exitCode;
+  constructor(params) {
+    super(params.message);
+    this.name = "CliError";
+    this.kind = params.kind;
+    this.status = params.status;
+    this.exitCode = params.exitCode;
+    this.details = params.details ?? {};
+  }
+};
+function mapStatusToExitCode(status) {
+  if (status === 401) {
+    return EXIT_CODES.missingOrInvalidAuth;
+  }
+  if (status === 403) {
+    return EXIT_CODES.forbidden;
+  }
+  if (status === 404) {
+    return EXIT_CODES.notFound;
+  }
+  if (status === 400 || status === 422) {
+    return EXIT_CODES.validationFailure;
+  }
+  if (status >= 500) {
+    return EXIT_CODES.networkOrUpstream;
+  }
+  return EXIT_CODES.generic;
+}
+
+// src/config.ts
+var DEFAULT_TIMEOUT_MS = 1e4;
+var configSchema = z.object({
+  baseUrl: z.url(),
+  token: z.string().min(1),
+  timeoutMs: z.number().int().positive(),
+  debug: z.boolean(),
+  agentName: z.string().min(1).optional(),
+  agentRunId: z.string().min(1).optional(),
+  requestId: z.string().min(1).optional(),
+  openapiPath: z.string().min(1).optional(),
+  openapiUrl: z.url().optional(),
+  openapiVersion: z.string().min(1).optional()
+});
+function parseTimeoutMs(raw) {
+  if (typeof raw === "number" && Number.isFinite(raw) && raw > 0) {
+    return raw;
+  }
+  if (typeof raw === "string" && raw.trim() !== "") {
+    const parsed = Number(raw);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return DEFAULT_TIMEOUT_MS;
+}
+function toOptionalNonEmpty(raw) {
+  if (typeof raw !== "string") {
+    return void 0;
+  }
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function parseDebug(rawDebugOption, rawDebugEnv) {
+  if (typeof rawDebugOption === "boolean") {
+    return rawDebugOption;
+  }
+  if (!rawDebugEnv) {
+    return false;
+  }
+  const lowered = rawDebugEnv.toLowerCase();
+  return lowered === "1" || lowered === "true" || lowered === "yes";
+}
+function getConfig(options) {
+  const token = process.env.WAVE_API_TOKEN ?? process.env.WAVE_JWT ?? options.token ?? options.jwt;
+  if (!token) {
+    throw new CliError({
+      message: "Missing API token. Set WAVE_API_TOKEN (or WAVE_JWT) or pass --token/--jwt.",
+      kind: "missing_auth",
+      status: 401,
+      exitCode: EXIT_CODES.missingOrInvalidAuth
+    });
+  }
+  const baseUrl = options.baseUrl ?? process.env.WAVE_API_BASE_URL ?? process.env.WAVE_API_URL;
+  if (!baseUrl) {
+    throw new CliError({
+      message: "Missing API base URL. Set WAVE_API_BASE_URL (or WAVE_API_URL) or pass --base-url.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  const parsed = configSchema.safeParse({
+    baseUrl,
+    token,
+    timeoutMs: parseTimeoutMs(options.timeoutMs ?? process.env.WAVE_TIMEOUT_MS),
+    debug: parseDebug(options.debug, process.env.WAVE_DEBUG),
+    agentName: toOptionalNonEmpty(options.agentName ?? process.env.WAVE_AGENT_NAME),
+    agentRunId: toOptionalNonEmpty(options.agentRunId ?? process.env.WAVE_AGENT_RUN_ID),
+    requestId: toOptionalNonEmpty(options.requestId ?? process.env.WAVE_REQUEST_ID),
+    openapiPath: toOptionalNonEmpty(options.openapiPath ?? process.env.WAVE_OPENAPI_PATH),
+    openapiUrl: toOptionalNonEmpty(options.openapiUrl ?? process.env.WAVE_OPENAPI_URL),
+    openapiVersion: toOptionalNonEmpty(
+      options.openapiVersion ?? process.env.WAVE_OPENAPI_VERSION
+    )
+  });
+  if (!parsed.success) {
+    throw new CliError({
+      message: "Invalid CLI configuration.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: { issues: parsed.error.issues }
+    });
+  }
+  return parsed.data;
+}
+
+// src/client/httpClient.ts
+import { randomUUID } from "crypto";
+function buildEnvelope(params) {
+  return {
+    ok: params.ok,
+    command: params.command,
+    status: params.status,
+    data: params.data,
+    error: params.error,
+    meta: { requestId: params.requestId }
+  };
+}
+function parseJsonSafely(input) {
+  try {
+    return JSON.parse(input);
+  } catch {
+    return null;
+  }
+}
+function redactForLogs(value) {
+  if (value.length <= 8) {
+    return "[redacted]";
+  }
+  return `${value.slice(0, 4)}...[redacted]...${value.slice(-4)}`;
+}
+function debugLog(config, message) {
+  if (!config.debug) {
+    return;
+  }
+  process.stderr.write(`[wave:debug] ${message}
+`);
+}
+async function executeFetch(params) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), params.input.config.timeoutMs);
+  try {
+    return await fetch(params.url, {
+      method: params.input.method,
+      headers: {
+        Authorization: `Bearer ${params.input.config.token}`,
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "X-Origin": "langgraph-cli",
+        "X-Request-Id": params.requestId,
+        ...params.input.config.agentName ? { "X-Agent-Name": params.input.config.agentName } : {},
+        ...params.input.config.agentRunId ? { "X-Agent-Run-Id": params.input.config.agentRunId } : {}
+      },
+      body: params.input.body && params.input.method !== "GET" ? JSON.stringify(params.input.body) : void 0,
+      signal: controller.signal
+    });
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+function errorFromPayload(payload, status) {
+  if (typeof payload === "object" && payload !== null) {
+    const asRecord = payload;
+    if ("error" in asRecord && typeof asRecord.error === "object" && asRecord.error !== null) {
+      const inner = asRecord.error;
+      return {
+        code: String(inner.code ?? `http_${status}`),
+        message: String(inner.message ?? "Request failed."),
+        details: typeof inner.details === "object" && inner.details !== null ? inner.details : {}
+      };
+    }
+  }
+  return {
+    code: `http_${status}`,
+    message: `HTTP ${status}`,
+    details: {}
+  };
+}
+async function httpRequest(input) {
+  const base = new URL(input.config.baseUrl);
+  const url = new URL(input.path, base);
+  const requestId = input.config.requestId ?? randomUUID();
+  const maxAttempts = input.method === "GET" ? 2 : 1;
+  debugLog(
+    input.config,
+    `request command=${input.command} method=${input.method} url=${url.toString()} token=${redactForLogs(
+      input.config.token
+    )}`
+  );
+  let attempt = 0;
+  while (attempt < maxAttempts) {
+    attempt += 1;
+    try {
+      const response = await executeFetch({ requestId, url, input });
+      const responseRequestId = response.headers.get("x-request-id") ?? requestId;
+      const text = await response.text();
+      const payload = text ? parseJsonSafely(text) : null;
+      if (response.ok) {
+        return {
+          envelope: buildEnvelope({
+            ok: true,
+            command: input.command,
+            status: response.status,
+            data: payload && typeof payload === "object" ? payload : { value: payload },
+            error: null,
+            requestId: responseRequestId
+          }),
+          exitCode: EXIT_CODES.success
+        };
+      }
+      return {
+        envelope: buildEnvelope({
+          ok: false,
+          command: input.command,
+          status: response.status,
+          data: null,
+          error: errorFromPayload(payload, response.status),
+          requestId: responseRequestId
+        }),
+        exitCode: mapStatusToExitCode(response.status)
+      };
+    } catch (error) {
+      const isRetryable = input.method === "GET" && attempt < maxAttempts;
+      if (isRetryable) {
+        debugLog(input.config, `retry command=${input.command} attempt=${attempt + 1}`);
+        continue;
+      }
+      const message = error instanceof Error ? error.message : "Network error.";
+      const status = 503;
+      return {
+        envelope: buildEnvelope({
+          ok: false,
+          command: input.command,
+          status,
+          data: null,
+          error: {
+            code: "network_error",
+            message,
+            details: {}
+          },
+          requestId
+        }),
+        exitCode: EXIT_CODES.networkOrUpstream
+      };
+    }
+  }
+  return {
+    envelope: buildEnvelope({
+      ok: false,
+      command: input.command,
+      status: 503,
+      data: null,
+      error: {
+        code: "network_error",
+        message: "Network request failed.",
+        details: {}
+      },
+      requestId
+    }),
+    exitCode: EXIT_CODES.networkOrUpstream
+  };
+}
+
+// src/output.ts
+function printEnvelope(envelope) {
+  process.stdout.write(`${JSON.stringify(envelope)}
+`);
+}
+function printEnvelopeAndExit(params) {
+  printEnvelope(params.envelope);
+  process.exit(params.exitCode ?? EXIT_CODES.success);
+}
+
+// src/commandRunner.ts
+function buildCliErrorEnvelope(params) {
+  return {
+    ok: false,
+    command: params.command,
+    status: params.status,
+    data: null,
+    error: {
+      code: params.code,
+      message: params.message,
+      details: params.details ?? {}
+    },
+    meta: {
+      requestId: "local_error"
+    }
+  };
+}
+async function runApiCommand(input) {
+  try {
+    const config = getConfig(input.runtimeOptions);
+    const result = await httpRequest({
+      config,
+      command: input.command,
+      method: input.method,
+      path: input.path,
+      body: input.body
+    });
+    printEnvelopeAndExit(result);
+  } catch (error) {
+    if (error instanceof CliError) {
+      printEnvelopeAndExit({
+        envelope: buildCliErrorEnvelope({
+          command: input.command,
+          status: error.status,
+          code: error.kind,
+          message: error.message,
+          details: error.details
+        }),
+        exitCode: error.exitCode
+      });
+    }
+    const message = error instanceof Error ? error.message : "Unexpected error.";
+    printEnvelopeAndExit({
+      envelope: buildCliErrorEnvelope({
+        command: input.command,
+        status: 500,
+        code: "generic_error",
+        message
+      }),
+      exitCode: EXIT_CODES.generic
+    });
+  }
+}
+
+// src/commands/runtimeOptions.ts
+function pickRuntimeOptions(options) {
+  return {
+    token: options.token,
+    jwt: options.jwt,
+    baseUrl: options.baseUrl,
+    timeoutMs: options.timeoutMs,
+    debug: options.debug,
+    agentName: options.agentName,
+    agentRunId: options.agentRunId,
+    requestId: options.requestId,
+    openapiPath: options.openapiPath,
+    openapiUrl: options.openapiUrl,
+    openapiVersion: options.openapiVersion
+  };
+}
+
+// src/commands/organization.ts
+function normalize(input) {
+  if (!input) {
+    return void 0;
+  }
+  const trimmed = input.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function resolveOrganizationId(raw) {
+  const organizationId = normalize(process.env.WAVE_ORGANIZATION_ID) ?? normalize(process.env.WAVE_ORG_ID) ?? normalize(raw);
+  if (!organizationId) {
+    throw new CliError({
+      message: "Missing organization ID. Set WAVE_ORGANIZATION_ID (or WAVE_ORG_ID) or pass --organization-id.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  return organizationId;
+}
+
+// src/commands/tasks.ts
+var projectIdSchema = z2.string().min(1);
+var idSchema = z2.string().min(1);
+var summarySchema = z2.string().min(1);
+function registerTaskCommands(program) {
+  const tasks = program.command("tasks").description("Task operations");
+  tasks.command("list").requiredOption("--project-id <projectId>").action(async (opts, cmd) => {
+    const projectId = projectIdSchema.parse(opts.projectId);
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    await runApiCommand({
+      command: "tasks.list",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "GET",
+      path: `/organizations/${encodeURIComponent(organizationId)}/tasks?project_id=${encodeURIComponent(projectId)}`
+    });
+  });
+  tasks.command("show").requiredOption("--id <id>").action(async (opts, cmd) => {
+    const parsed = idSchema.parse(opts.id);
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    await runApiCommand({
+      command: "tasks.show",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "GET",
+      path: `/organizations/${encodeURIComponent(organizationId)}/tasks/${encodeURIComponent(parsed)}`
+    });
+  });
+  tasks.command("create").requiredOption("--project-id <projectId>").option("--title <title>", "Legacy alias for --summary").option("--summary <summary>").action(async (opts, cmd) => {
+    const projectId = projectIdSchema.parse(opts.projectId);
+    const summary = summarySchema.parse(opts.summary ?? opts.title);
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    await runApiCommand({
+      command: "tasks.create",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "POST",
+      path: `/organizations/${encodeURIComponent(organizationId)}/tasks`,
+      body: {
+        task: {
+          project_id: projectId,
+          summary
+        }
+      }
+    });
+  });
+  tasks.command("update").requiredOption("--id <id>").option("--summary <summary>").option("--description <description>").option("--status <status>").option("--priority <priority>").option("--due-date <dueDate>").option("--member-id <memberId>").action(async (opts, cmd) => {
+    const id = idSchema.parse(opts.id);
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    const taskPayload = {
+      ...opts.summary ? { summary: String(opts.summary) } : {},
+      ...opts.description ? { description: String(opts.description) } : {},
+      ...opts.status ? { status: String(opts.status) } : {},
+      ...opts.priority ? { priority: String(opts.priority) } : {},
+      ...opts.dueDate ? { due_date: String(opts.dueDate) } : {},
+      ...opts.memberId ? { member_id: String(opts.memberId) } : {}
+    };
+    if (Object.keys(taskPayload).length === 0) {
+      throw new CliError({
+        message: "tasks update requires at least one patch field (summary, description, status, priority, due-date, member-id).",
+        kind: "invalid_args",
+        status: 400,
+        exitCode: EXIT_CODES.invalidArgs
+      });
+    }
+    await runApiCommand({
+      command: "tasks.update",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "PATCH",
+      path: `/organizations/${encodeURIComponent(organizationId)}/tasks/${encodeURIComponent(id)}`,
+      body: {
+        task: taskPayload
+      }
+    });
+  });
+}
+
+// src/commands/projects.ts
+import { z as z4 } from "zod";
+
+// src/commands/entityCrud.ts
+import { z as z3 } from "zod";
+var idSchema2 = z3.string().min(1);
+function parseJsonObject(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("JSON payload must be an object.");
+    }
+    return parsed;
+  } catch (error) {
+    throw new CliError({
+      message: error instanceof Error ? `Invalid --data-json: ${error.message}` : "Invalid --data-json.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+}
+function normalizeBody(raw, rootKey) {
+  const payload = parseJsonObject(raw);
+  const rooted = payload[rootKey];
+  if (rooted && typeof rooted === "object" && !Array.isArray(rooted)) {
+    return payload;
+  }
+  return { [rootKey]: payload };
+}
+function assertRequiredCreateFields(body, rootKey, requiredFields) {
+  if (!requiredFields || requiredFields.length === 0) {
+    return;
+  }
+  const entity = body[rootKey];
+  if (!entity || typeof entity !== "object" || Array.isArray(entity)) {
+    throw new CliError({
+      message: `Invalid payload. Expected object at "${rootKey}".`,
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  const entityRecord = entity;
+  const missing = requiredFields.filter((field) => {
+    const value = entityRecord[field];
+    return !(typeof value === "string" && value.trim().length > 0);
+  });
+  if (missing.length > 0) {
+    throw new CliError({
+      message: `Missing required create fields for ${rootKey}: ${missing.join(", ")}.`,
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: { requiredFields, rootKey }
+    });
+  }
+}
+function registerEntityCrudCommands(program, config) {
+  const entityCommand = program.command(config.command).description(config.description);
+  entityCommand.command("create").requiredOption("--data-json <dataJson>", "JSON object, optionally wrapped with root key").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    const body = normalizeBody(String(opts.dataJson), config.rootKey);
+    assertRequiredCreateFields(body, config.rootKey, config.requiredCreateFields);
+    await runApiCommand({
+      command: `${config.command}.create`,
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "POST",
+      path: `/organizations/${encodeURIComponent(organizationId)}/${config.resourcePath}`,
+      body
+    });
+  });
+  entityCommand.command("update").requiredOption("--id <id>").requiredOption("--data-json <dataJson>", "JSON object, optionally wrapped with root key").action(async (opts, cmd) => {
+    const id = idSchema2.parse(opts.id);
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    const body = normalizeBody(String(opts.dataJson), config.rootKey);
+    await runApiCommand({
+      command: `${config.command}.update`,
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "PATCH",
+      path: `/organizations/${encodeURIComponent(organizationId)}/${config.resourcePath}/${encodeURIComponent(id)}`,
+      body
+    });
+  });
+}
+var __testables = {
+  parseJsonObject,
+  normalizeBody,
+  assertRequiredCreateFields
+};
+
+// src/commands/projects.ts
+var idSchema3 = z4.string().min(1);
+function registerProjectCommands(program) {
+  const projects = program.command("projects").description("Project operations");
+  projects.command("list").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    await runApiCommand({
+      command: "projects.list",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "GET",
+      path: `/organizations/${encodeURIComponent(organizationId)}/projects`
+    });
+  });
+  projects.command("show").requiredOption("--id <id>").action(async (opts, cmd) => {
+    const id = idSchema3.parse(opts.id);
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    await runApiCommand({
+      command: "projects.show",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "GET",
+      path: `/organizations/${encodeURIComponent(organizationId)}/projects/${encodeURIComponent(id)}`
+    });
+  });
+  projects.command("create").requiredOption("--data-json <dataJson>", 'JSON object for project or {"project": {...}}').action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    const body = __testables.normalizeBody(String(opts.dataJson), "project");
+    await runApiCommand({
+      command: "projects.create",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "POST",
+      path: `/organizations/${encodeURIComponent(organizationId)}/projects`,
+      body
+    });
+  });
+  projects.command("update").requiredOption("--id <id>").requiredOption("--data-json <dataJson>", 'JSON object for project or {"project": {...}}').action(async (opts, cmd) => {
+    const id = idSchema3.parse(opts.id);
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    const body = __testables.normalizeBody(String(opts.dataJson), "project");
+    await runApiCommand({
+      command: "projects.update",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "PATCH",
+      path: `/organizations/${encodeURIComponent(organizationId)}/projects/${encodeURIComponent(id)}`,
+      body
+    });
+  });
+}
+
+// src/commands/rocks.ts
+import { z as z5 } from "zod";
+var idSchema4 = z5.string().min(1);
+var rockCollectionIdSchema = z5.string().min(1);
+var statusSchema = z5.enum(["on_track", "at_risk", "off_track"]);
+function registerRockCommands(program) {
+  const rocks = program.command("rocks").description("Rock operations");
+  rocks.command("list").option("--rock-collection-id <rockCollectionId>").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    const rockCollectionId = opts.rockCollectionId ? rockCollectionIdSchema.parse(opts.rockCollectionId) : void 0;
+    await runApiCommand({
+      command: "rocks.list",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "GET",
+      path: rockCollectionId ? `/organizations/${encodeURIComponent(organizationId)}/rocks?rock_collection_id=${encodeURIComponent(rockCollectionId)}` : `/organizations/${encodeURIComponent(organizationId)}/rocks`
+    });
+  });
+  rocks.command("show").requiredOption("--id <id>").action(async (opts, cmd) => {
+    const id = idSchema4.parse(opts.id);
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    await runApiCommand({
+      command: "rocks.show",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "GET",
+      path: `/organizations/${encodeURIComponent(organizationId)}/rocks/${encodeURIComponent(id)}`
+    });
+  });
+  rocks.command("update-status").requiredOption("--id <id>").requiredOption("--status <status>").action(async (opts, cmd) => {
+    const id = idSchema4.parse(opts.id);
+    const status = statusSchema.parse(opts.status);
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    await runApiCommand({
+      command: "rocks.update-status",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "PATCH",
+      path: `/organizations/${encodeURIComponent(organizationId)}/rocks/${encodeURIComponent(id)}`,
+      body: { rock: { status } }
+    });
+  });
+  rocks.command("create").requiredOption("--data-json <dataJson>", 'JSON object for rock or {"rock": {...}}').action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    const body = __testables.normalizeBody(String(opts.dataJson), "rock");
+    __testables.assertRequiredCreateFields(body, "rock", ["rock_collection_id"]);
+    await runApiCommand({
+      command: "rocks.create",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "POST",
+      path: `/organizations/${encodeURIComponent(organizationId)}/rocks`,
+      body
+    });
+  });
+  rocks.command("update").requiredOption("--id <id>").requiredOption("--data-json <dataJson>", 'JSON object for rock or {"rock": {...}}').action(async (opts, cmd) => {
+    const id = idSchema4.parse(opts.id);
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    const body = __testables.normalizeBody(String(opts.dataJson), "rock");
+    await runApiCommand({
+      command: "rocks.update",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "PATCH",
+      path: `/organizations/${encodeURIComponent(organizationId)}/rocks/${encodeURIComponent(id)}`,
+      body
+    });
+  });
+}
+
+// src/commands/meetings.ts
+import { z as z6 } from "zod";
+var idSchema5 = z6.string().min(1);
+var notesSchema = z6.string().min(1);
+function registerMeetingCommands(program) {
+  const meetings = program.command("meetings").description("Meeting operations");
+  meetings.command("show").requiredOption("--id <id>").action(async (opts, cmd) => {
+    const id = idSchema5.parse(opts.id);
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    await runApiCommand({
+      command: "meetings.show",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "GET",
+      path: `/organizations/${encodeURIComponent(organizationId)}/meetings/${encodeURIComponent(id)}`
+    });
+  });
+  meetings.command("notes").requiredOption("--id <id>").requiredOption("--content <content>").action(async (opts, cmd) => {
+    const id = idSchema5.parse(opts.id);
+    const notes = notesSchema.parse(opts.content);
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    await runApiCommand({
+      command: "meeting-notes.create",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "PATCH",
+      path: `/organizations/${encodeURIComponent(organizationId)}/meetings/${encodeURIComponent(id)}`,
+      body: {
+        meeting: {
+          notes
+        }
+      }
+    });
+  });
+  meetings.command("create").requiredOption("--data-json <dataJson>", 'JSON object for meeting or {"meeting": {...}}').action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    const body = __testables.normalizeBody(String(opts.dataJson), "meeting");
+    await runApiCommand({
+      command: "meetings.create",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "POST",
+      path: `/organizations/${encodeURIComponent(organizationId)}/meetings`,
+      body
+    });
+  });
+  meetings.command("update").requiredOption("--id <id>").requiredOption("--data-json <dataJson>", 'JSON object for meeting or {"meeting": {...}}').action(async (opts, cmd) => {
+    const id = idSchema5.parse(opts.id);
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    const body = __testables.normalizeBody(String(opts.dataJson), "meeting");
+    await runApiCommand({
+      command: "meetings.update",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "PATCH",
+      path: `/organizations/${encodeURIComponent(organizationId)}/meetings/${encodeURIComponent(id)}`,
+      body
+    });
+  });
+}
+
+// src/commands/members.ts
+import { z as z7 } from "zod";
+var idSchema6 = z7.string().min(1);
+function registerMemberCommands(program) {
+  const members = program.command("members").description("Member operations");
+  members.command("list").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    await runApiCommand({
+      command: "members.list",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "GET",
+      path: `/organizations/${encodeURIComponent(organizationId)}/members`
+    });
+  });
+  members.command("show").requiredOption("--id <id>").action(async (opts, cmd) => {
+    const id = idSchema6.parse(opts.id);
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    await runApiCommand({
+      command: "members.show",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "GET",
+      path: `/organizations/${encodeURIComponent(organizationId)}/members/${encodeURIComponent(id)}`
+    });
+  });
+  members.command("create").requiredOption("--data-json <dataJson>", 'JSON object for member or {"member": {...}}').action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    const body = __testables.normalizeBody(String(opts.dataJson), "member");
+    await runApiCommand({
+      command: "members.create",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "POST",
+      path: `/organizations/${encodeURIComponent(organizationId)}/members`,
+      body
+    });
+  });
+  members.command("update").requiredOption("--id <id>").requiredOption("--data-json <dataJson>", 'JSON object for member or {"member": {...}}').action(async (opts, cmd) => {
+    const id = idSchema6.parse(opts.id);
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    const body = __testables.normalizeBody(String(opts.dataJson), "member");
+    await runApiCommand({
+      command: "members.update",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "PATCH",
+      path: `/organizations/${encodeURIComponent(organizationId)}/members/${encodeURIComponent(id)}`,
+      body
+    });
+  });
+}
+
+// src/commands/issues.ts
+import { z as z8 } from "zod";
+var issueGroupIdSchema = z8.string().min(1);
+var idSchema7 = z8.string().min(1);
+var nameSchema = z8.string().min(1);
+var issueTypeSchema = z8.string().min(1);
+function registerIssueCommands(program) {
+  const issues = program.command("issues").description("Issue operations");
+  issues.command("create").requiredOption("--issue-group-id <issueGroupId>").requiredOption("--name <name>").requiredOption("--issue-type <issueType>").option("--status <status>").option("--priority <priority>").option("--description <description>").option("--due-by <dueBy>").option("--member-id <memberId>").action(async (opts, cmd) => {
+    const issueGroupId = issueGroupIdSchema.parse(opts.issueGroupId);
+    const name = nameSchema.parse(opts.name);
+    const issueType = issueTypeSchema.parse(opts.issueType);
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    await runApiCommand({
+      command: "issues.create",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "POST",
+      path: `/organizations/${encodeURIComponent(organizationId)}/issues`,
+      body: {
+        issue: {
+          issue_group_id: issueGroupId,
+          name,
+          issue_type: issueType,
+          ...opts.status ? { status: String(opts.status) } : {},
+          ...opts.priority ? { priority: String(opts.priority) } : {},
+          ...opts.description ? { description: String(opts.description) } : {},
+          ...opts.dueBy ? { due_by: String(opts.dueBy) } : {},
+          ...opts.memberId ? { member_id: String(opts.memberId) } : {}
+        }
+      }
+    });
+  });
+  issues.command("update").requiredOption("--id <id>").requiredOption("--data-json <dataJson>", 'JSON object for issue or {"issue": {...}}').action(async (opts, cmd) => {
+    const id = idSchema7.parse(opts.id);
+    const globalOpts = cmd.optsWithGlobals();
+    const organizationId = resolveOrganizationId(globalOpts.organizationId);
+    const body = __testables.normalizeBody(String(opts.dataJson), "issue");
+    await runApiCommand({
+      command: "issues.update",
+      runtimeOptions: pickRuntimeOptions(globalOpts),
+      method: "PATCH",
+      path: `/organizations/${encodeURIComponent(organizationId)}/issues/${encodeURIComponent(id)}`,
+      body
+    });
+  });
+}
+
+// src/commands/systemTools.ts
+function registerSystemToolCommands(program) {
+  registerEntityCrudCommands(program, {
+    command: "lists",
+    description: "List operations",
+    resourcePath: "lists",
+    rootKey: "list"
+  });
+  registerEntityCrudCommands(program, {
+    command: "list-items",
+    description: "List item operations",
+    resourcePath: "list_items",
+    rootKey: "list_item",
+    requiredCreateFields: ["list_id"]
+  });
+  registerEntityCrudCommands(program, {
+    command: "issue-groups",
+    description: "Issue group operations",
+    resourcePath: "issue_groups",
+    rootKey: "issue_group"
+  });
+  registerEntityCrudCommands(program, {
+    command: "todo-groups",
+    description: "To-do group operations",
+    resourcePath: "todo_groups",
+    rootKey: "todo_group"
+  });
+  registerEntityCrudCommands(program, {
+    command: "todos",
+    description: "To-do operations",
+    resourcePath: "todos",
+    rootKey: "todo",
+    requiredCreateFields: ["todo_group_id"]
+  });
+  registerEntityCrudCommands(program, {
+    command: "rock-collections",
+    description: "Rock collection operations",
+    resourcePath: "rock_collections",
+    rootKey: "rock_collection"
+  });
+  registerEntityCrudCommands(program, {
+    command: "knowledge",
+    description: "Knowledge content operations",
+    resourcePath: "contents",
+    rootKey: "content"
+  });
+  registerEntityCrudCommands(program, {
+    command: "stand-ups",
+    description: "Stand-up operations",
+    resourcePath: "stand_ups",
+    rootKey: "stand_up"
+  });
+  registerEntityCrudCommands(program, {
+    command: "news",
+    description: "News operations",
+    resourcePath: "headlines",
+    rootKey: "headline"
+  });
+  registerEntityCrudCommands(program, {
+    command: "questions",
+    description: "Q&A forum operations",
+    resourcePath: "questions",
+    rootKey: "question"
+  });
+  registerEntityCrudCommands(program, {
+    command: "pulse",
+    description: "Pulse operations",
+    resourcePath: "health_updates",
+    rootKey: "health_update"
+  });
+  registerEntityCrudCommands(program, {
+    command: "surveys",
+    description: "Survey operations",
+    resourcePath: "surveys",
+    rootKey: "survey"
+  });
+  registerEntityCrudCommands(program, {
+    command: "accountability",
+    description: "Accountability operations",
+    resourcePath: "responsibilities",
+    rootKey: "responsibility"
+  });
+  registerEntityCrudCommands(program, {
+    command: "kpis",
+    description: "KPI operations",
+    resourcePath: "smart_kpis",
+    rootKey: "smart_kpi"
+  });
+  registerEntityCrudCommands(program, {
+    command: "scorecard-groups",
+    description: "Scorecard group operations",
+    resourcePath: "measurable_groups",
+    rootKey: "measurable_group"
+  });
+  registerEntityCrudCommands(program, {
+    command: "scorecards",
+    description: "Scorecard item operations",
+    resourcePath: "measurables",
+    rootKey: "measurable",
+    requiredCreateFields: ["measurable_group_id"]
+  });
+  registerEntityCrudCommands(program, {
+    command: "customers",
+    description: "CRM customer operations",
+    resourcePath: "customers",
+    rootKey: "customer"
+  });
+  registerEntityCrudCommands(program, {
+    command: "contacts",
+    description: "CRM contact operations",
+    resourcePath: "contacts",
+    rootKey: "contact"
+  });
+  registerEntityCrudCommands(program, {
+    command: "annual-objectives",
+    description: "Foundation annual objective operations",
+    resourcePath: "annual_objectives",
+    rootKey: "annual_objective"
+  });
+  registerEntityCrudCommands(program, {
+    command: "quarterly-objectives",
+    description: "Foundation quarterly objective operations",
+    resourcePath: "quarterly_objectives",
+    rootKey: "quarterly_objective"
+  });
+}
+
+// src/cli.ts
+function buildCli() {
+  const program = new Command();
+  program.name("wave").description("Wave agent CLI").showHelpAfterError(false).allowExcessArguments(false).option("--token <token>", "API token (prefer WAVE_API_TOKEN env var)").option("--jwt <jwt>", "Legacy alias for --token (prefer WAVE_API_TOKEN env var)").option(
+    "--base-url <baseUrl>",
+    "API base URL (prefer WAVE_API_BASE_URL env var)"
+  ).option(
+    "--organization-id <organizationId>",
+    "Organization ID (prefer WAVE_ORGANIZATION_ID env var)"
+  ).option("--timeout-ms <timeoutMs>", "HTTP timeout in milliseconds").option("--debug", "Enable debug logs to stderr").option("--agent-name <agentName>", "Agent name for tracing").option("--agent-run-id <agentRunId>", "Agent run identifier for tracing").option("--request-id <requestId>", "Request identifier").option(
+    "--openapi-path <openapiPath>",
+    "Optional local OpenAPI file path for contract-aware tooling"
+  ).option(
+    "--openapi-url <openapiUrl>",
+    "Optional OpenAPI URL for contract-aware tooling"
+  ).option(
+    "--openapi-version <openapiVersion>",
+    "Optional pinned OpenAPI version/hash"
+  ).exitOverride();
+  registerTaskCommands(program);
+  registerProjectCommands(program);
+  registerRockCommands(program);
+  registerMeetingCommands(program);
+  registerMemberCommands(program);
+  registerIssueCommands(program);
+  registerSystemToolCommands(program);
+  return program;
+}
+
+// src/index.ts
+function printCliFailure(params) {
+  printEnvelopeAndExit({
+    envelope: {
+      ok: false,
+      command: "cli",
+      status: params.status,
+      data: null,
+      error: {
+        code: params.code,
+        message: params.message,
+        details: params.details ?? {}
+      },
+      meta: {
+        requestId: "local_error"
+      }
+    },
+    exitCode: params.exitCode
+  });
+}
+async function main() {
+  const program = buildCli();
+  await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+  if (error instanceof CliError) {
+    printCliFailure({
+      status: error.status,
+      code: error.kind,
+      message: error.message,
+      details: error.details,
+      exitCode: error.exitCode
+    });
+  }
+  if (error instanceof CommanderError) {
+    printCliFailure({
+      status: 400,
+      code: "invalid_args",
+      message: error.message,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  if (error instanceof ZodError || error instanceof InvalidArgumentError) {
+    printCliFailure({
+      status: 400,
+      code: "invalid_args",
+      message: "Invalid command arguments.",
+      details: {
+        issues: error instanceof ZodError ? error.issues : [{ message: error.message, code: "invalid_argument" }]
+      },
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  const message = error instanceof Error ? error.message : "Unexpected error.";
+  printCliFailure({
+    status: 500,
+    code: "generic_error",
+    message,
+    exitCode: EXIT_CODES.generic
+  });
+});