@getpilfer/cli 0.1.1 → 0.1.3

package/dist/chunk-NFFHTNJE.js

@@ -0,0 +1,1161 @@
+#!/usr/bin/env node
+import {
+  apiRequest,
+  coerceBodyFlag,
+  fetchList,
+  formatErrorPayload,
+  getBaseUrl,
+  getDefaultOutputFormat,
+  mergeBody,
+  printList,
+  printOutput,
+  printStructuredError
+} from "./chunk-CXNVJZ4C.js";
+import {
+  resolveToken
+} from "./chunk-GZ4DXDQM.js";
+
+// src/build-program.ts
+import { createRequire } from "module";
+import { Command } from "commander";
+
+// src/lib/command-discovery.ts
+function discoverCommands(program, version) {
+  return {
+    cli: "pilfer",
+    version,
+    outputFormats: ["json", "table", "csv", "jsonl"],
+    auth: {
+      tokenSources: ["--token", "PILFER_API_TOKEN", "credentials.json"],
+      baseUrlSources: ["--base-url", "--api", "PILFER_API_BASE_URL", "config", "default"]
+    },
+    commands: program.commands.map(discoverCommand)
+  };
+}
+function discoverCommand(command) {
+  const commandWithInternals = command;
+  return {
+    name: command.name(),
+    aliases: command.aliases(),
+    description: command.description(),
+    usage: command.usage(),
+    arguments: (commandWithInternals.registeredArguments ?? []).map((arg) => ({
+      name: arg.name(),
+      required: arg.required,
+      variadic: arg.variadic
+    })),
+    options: command.options.map((option) => ({
+      flags: option.flags,
+      description: option.description,
+      required: option.required,
+      optional: option.optional
+    })),
+    commands: command.commands.map(discoverCommand)
+  };
+}
+function buildResourceSchema(payload) {
+  const resources = payload.commands.filter(
+    (command) => command.commands.some(
+      (subcommand) => ["list", "get", "create", "update", "delete"].includes(subcommand.name)
+    )
+  ).map((command) => ({
+    name: command.name,
+    actions: command.commands.map((subcommand) => ({
+      name: subcommand.name,
+      arguments: subcommand.arguments,
+      options: subcommand.options
+    }))
+  }));
+  return {
+    cli: payload.cli,
+    version: payload.version,
+    outputFormats: payload.outputFormats,
+    auth: payload.auth,
+    resources
+  };
+}
+
+// src/lib/reports.ts
+var PRIORITY_ORDER = ["urgent", "high", "medium", "low", "none"];
+var ACTIVE_SCOUT_STATUSES = ["New", "In Progress", "In Review", "Shortlist", "Approved"];
+function buildShortlistRows(scouts, nowMs = Date.now()) {
+  return scouts.filter(isRecord).filter((scout) => scout.status === "Shortlist").map((scout) => scoutToQueueRow(scout, nowMs)).sort(
+    (a, b) => comparePriority(a.priority, b.priority) || b.estimatedCost - a.estimatedCost || b.ageDays - a.ageDays
+  );
+}
+function buildPipelineGroups(scouts, nowMs = Date.now()) {
+  const rows = scouts.filter(isRecord).map((scout) => scoutToQueueRow(scout, nowMs));
+  return ACTIVE_SCOUT_STATUSES.map((status) => {
+    const statusRows = rows.filter((row) => row.status === status);
+    const totalAge = statusRows.reduce((sum2, row) => sum2 + row.ageDays, 0);
+    const sortedByAge = [...statusRows].sort((a, b) => b.ageDays - a.ageDays);
+    return {
+      status,
+      count: statusRows.length,
+      totalEstimatedCost: sum(statusRows, "estimatedCost"),
+      averageAgeDays: statusRows.length > 0 ? Math.round(totalAge / statusRows.length) : 0,
+      oldestAgeDays: sortedByAge[0]?.ageDays ?? 0,
+      ...sortedByAge[0] ? { oldestScoutName: sortedByAge[0].name } : {}
+    };
+  });
+}
+function buildScoutingReport(scouts, sourcesByScout = {}, nowMs = Date.now()) {
+  const scoutRows = scouts.filter(isRecord).map((scout) => {
+    const id = stringValue(scout._id ?? scout.id);
+    return {
+      ...scout,
+      sources: sourcesByScout[id] ?? scout.sources
+    };
+  });
+  const queueRows = scoutRows.map((scout) => scoutToQueueRow(scout, nowMs));
+  const activeRows = queueRows.filter((row) => ACTIVE_SCOUT_STATUSES.includes(row.status));
+  const shortlistRows = buildShortlistRows(scoutRows, nowMs);
+  const statusCounts = queueRows.reduce((acc, row) => {
+    acc[row.status] = (acc[row.status] ?? 0) + 1;
+    return acc;
+  }, {});
+  return {
+    totalScouts: queueRows.length,
+    activeScouts: activeRows.length,
+    activeEstimatedCost: sum(activeRows, "estimatedCost"),
+    shortlist: {
+      count: shortlistRows.length,
+      totalEstimatedCost: sum(shortlistRows, "estimatedCost"),
+      ...shortlistRows[0] ? { largestScout: shortlistRows[0] } : {}
+    },
+    pipeline: buildPipelineGroups(scoutRows, nowMs),
+    missingSourceScouts: activeRows.filter((row) => (row.sourceCount ?? 0) === 0).sort(
+      (a, b) => comparePriority(a.priority, b.priority) || b.estimatedCost - a.estimatedCost || b.ageDays - a.ageDays
+    ),
+    statusCounts
+  };
+}
+function buildAssetReport(assets, scope = {}) {
+  const scoped = applyScope(assets.filter(isRecord), scope);
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const asset of scoped.rows) {
+    const category = categoryName(asset);
+    const current = byCategory.get(category) ?? { category, count: 0, totalCost: 0 };
+    current.count += 1;
+    current.totalCost += numberValue(asset.cost);
+    byCategory.set(category, current);
+  }
+  return {
+    totalAssets: scoped.rows.length,
+    totalCost: scoped.rows.reduce((total, asset) => total + numberValue(asset.cost), 0),
+    byCategory: Array.from(byCategory.values()).sort(
+      (a, b) => b.totalCost - a.totalCost || b.count - a.count
+    ),
+    ...scoped.warning ? { scopeWarning: scoped.warning } : {}
+  };
+}
+function buildBalanceReport(assets, scouts, scope = {}, nowMs = Date.now()) {
+  const scopedScouts = applyScope(scouts.filter(isRecord), scope);
+  const activeScouts = scopedScouts.rows.map((scout) => scoutToQueueRow(scout, nowMs)).filter((row) => ACTIVE_SCOUT_STATUSES.includes(row.status));
+  const shortlistRows = activeScouts.filter((row) => row.status === "Shortlist");
+  const assetReport = buildAssetReport(assets, scope);
+  const gapSignals = [];
+  if (activeScouts.length === 0) {
+    gapSignals.push({ kind: "no_active_scouts", message: "No active scouts in scope" });
+  }
+  if (assetReport.totalAssets === 0) {
+    gapSignals.push({ kind: "no_assets", message: "No assets in scope" });
+  }
+  if (assetReport.totalCost > 0 && activeScouts.length === 0) {
+    gapSignals.push({
+      kind: "maintenance_only",
+      message: "Scope has assets but no active scouting pipeline",
+      value: assetReport.totalCost
+    });
+  }
+  if (activeScouts.length > 0 && assetReport.totalAssets === 0) {
+    gapSignals.push({
+      kind: "scouting_without_assets",
+      message: "Scope has scouting pipeline but no owned assets yet",
+      value: sum(activeScouts, "estimatedCost")
+    });
+  }
+  const scopeWarning = scopedScouts.warning ?? assetReport.scopeWarning;
+  return {
+    scope,
+    assets: assetReport,
+    scouting: {
+      activeScouts: activeScouts.length,
+      activeEstimatedCost: sum(activeScouts, "estimatedCost"),
+      shortlistCount: shortlistRows.length,
+      shortlistEstimatedCost: sum(shortlistRows, "estimatedCost")
+    },
+    gapSignals,
+    ...scopeWarning ? { scopeWarning } : {}
+  };
+}
+function scoutToQueueRow(scout, nowMs = Date.now()) {
+  const sources = Array.isArray(scout.sources) ? scout.sources.filter(isRecord) : [];
+  return {
+    _id: stringValue(scout._id ?? scout.id),
+    name: stringValue(scout.name, "Untitled scout"),
+    status: stringValue(scout.status, "unknown"),
+    priority: stringValue(scout.priority, "none"),
+    estimatedCost: numberValue(scout.estimatedCost),
+    ageDays: ageDays(scout._creationTime, nowMs),
+    ...sources.length > 0 ? {
+      sourceCount: sources.length,
+      hasStarredSource: sources.some((source) => source.starred === true)
+    } : {}
+  };
+}
+function comparePriority(a, b) {
+  const aIndex = PRIORITY_ORDER.indexOf(a);
+  const bIndex = PRIORITY_ORDER.indexOf(b);
+  return (aIndex === -1 ? PRIORITY_ORDER.length : aIndex) - (bIndex === -1 ? PRIORITY_ORDER.length : bIndex);
+}
+function ageDays(creationTime, nowMs) {
+  const created = numberValue(creationTime);
+  if (created <= 0) return 0;
+  return Math.max(0, Math.floor((nowMs - created) / 864e5));
+}
+function sum(rows, field) {
+  return rows.reduce((total, row) => total + row[field], 0);
+}
+function applyScope(rows, scope) {
+  const key = scope.projectId ? "projectId" : scope.spaceId ? "spaceId" : null;
+  const value = scope.projectId ?? scope.spaceId;
+  if (!key || !value) return { rows };
+  const rowsWithScopeData = rows.filter((row) => hasScopeValue(row, key, value));
+  const anyHasScopeShape = rows.some((row) => hasScopeShape(row, key));
+  if (!anyHasScopeShape) {
+    return {
+      rows,
+      warning: `${key} filter requested, but REST payload has no relation data; totals are unfiltered`
+    };
+  }
+  return { rows: rowsWithScopeData };
+}
+function hasScopeShape(row, key) {
+  if (typeof row[key] === "string") return true;
+  const relationKey = key === "projectId" ? "projects" : "spaces";
+  return Array.isArray(row[relationKey]);
+}
+function hasScopeValue(row, key, value) {
+  if (row[key] === value) return true;
+  const relationKey = key === "projectId" ? "projects" : "spaces";
+  const relations = row[relationKey];
+  if (!Array.isArray(relations)) return false;
+  return relations.filter(isRecord).some((relation) => relation[key] === value || relation._id === value);
+}
+function categoryName(row) {
+  if (isRecord(row.category) && typeof row.category.name === "string") return row.category.name;
+  if (typeof row.categoryId === "string") return row.categoryId;
+  return "Uncategorized";
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function stringValue(value, fallback = "") {
+  return typeof value === "string" && value.trim() ? value : fallback;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/lib/resource-resolver.ts
+async function resolveResourceByName(options) {
+  const res = await options.request({
+    method: "GET",
+    path: options.resource,
+    token: options.token,
+    baseUrl: options.baseUrl
+  });
+  if (!res.ok) {
+    return {
+      ok: false,
+      status: res.status || 500,
+      message: res.error ?? "Request failed"
+    };
+  }
+  const rows = (res.data?.data ?? []).filter(
+    isRecord2
+  );
+  const expected = options.name.trim().toLowerCase();
+  const matches = rows.filter((row) => {
+    const raw = row[options.field];
+    return typeof raw === "string" && raw.trim().toLowerCase() === expected;
+  });
+  if (matches.length === 0) {
+    return {
+      ok: false,
+      status: 404,
+      message: `No ${options.resource} found where ${options.field} is ${JSON.stringify(options.name)}`
+    };
+  }
+  if (matches.length > 1) {
+    const candidates = matches.map((row) => ({
+      _id: row._id ?? row.id,
+      [options.field]: row[options.field]
+    }));
+    return {
+      ok: false,
+      status: 409,
+      message: `Multiple ${options.resource} matched ${options.field}=${JSON.stringify(options.name)}`,
+      candidates
+    };
+  }
+  return { ok: true, item: matches[0] };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/lib/source-body.ts
+function sourceBodyFromFlags(opts, isUpdate, exitWithError) {
+  const bodyFromFlags = {};
+  const fieldSpecs = [
+    { option: "url", field: "url", flag: "--url", kind: "string" },
+    { option: "name", field: "name", flag: "--name", kind: "string" },
+    { option: "title", field: "name", flag: "--title", kind: "string" },
+    { option: "description", field: "description", flag: "--description", kind: "string" },
+    { option: "price", field: "price", flag: "--price", kind: "number" },
+    { option: "image", field: "image", flag: "--image", kind: "string" },
+    { option: "imageUrl", field: "image", flag: "--image-url", kind: "string" },
+    { option: "address", field: "address", flag: "--address", kind: "string" },
+    { option: "sourceType", field: "sourceType", flag: "--source-type", kind: "string" },
+    { option: "condition", field: "condition", flag: "--condition", kind: "string" },
+    { option: "notes", field: "notes", flag: "--notes", kind: "string" },
+    { option: "starred", field: "starred", flag: "--starred", kind: "boolean" }
+  ];
+  for (const spec of fieldSpecs) {
+    const value = opts[spec.option];
+    const parsed = coerceBodyFlag(
+      value,
+      {
+        field: spec.field,
+        flag: spec.flag,
+        kind: spec.kind
+      },
+      exitWithError
+    );
+    if (parsed !== void 0) bodyFromFlags[spec.field] = parsed;
+  }
+  if (!isUpdate && Object.keys(bodyFromFlags).length === 0 && !opts.body) {
+    exitWithError(400, "Provide source fields or --body JSON");
+  }
+  return mergeBody(bodyFromFlags, opts.body);
+}
+
+// src/lib/workflows.ts
+async function purchaseScout(options) {
+  const scoutRes = await options.request({
+    method: "GET",
+    path: `scouts/${encodeURIComponent(options.scoutId)}`,
+    token: options.token,
+    baseUrl: options.baseUrl
+  });
+  if (!scoutRes.ok) return fail(scoutRes);
+  const scout = unwrapRecord(scoutRes.data);
+  if (!scout) {
+    return { ok: false, status: 404, error: "Scout not found" };
+  }
+  const assetBody = buildAssetBodyFromScout(scout, options);
+  if (options.dryRun) {
+    return {
+      ok: true,
+      status: 200,
+      data: { scout, assetBody, dryRun: true }
+    };
+  }
+  const assetRes = await options.request({
+    method: "POST",
+    path: "assets",
+    token: options.token,
+    baseUrl: options.baseUrl,
+    body: assetBody
+  });
+  if (!assetRes.ok) return fail(assetRes);
+  const updateRes = await options.request({
+    method: "PATCH",
+    path: `scouts/${encodeURIComponent(options.scoutId)}`,
+    token: options.token,
+    baseUrl: options.baseUrl,
+    body: { status: "Purchased" }
+  });
+  if (!updateRes.ok) {
+    return {
+      ok: false,
+      status: updateRes.status || 500,
+      error: updateRes.error ?? "Asset created but scout status update failed",
+      data: {
+        scout,
+        assetBody,
+        asset: unwrapData(assetRes.data)
+      }
+    };
+  }
+  return {
+    ok: true,
+    status: 200,
+    data: {
+      scout,
+      assetBody,
+      asset: unwrapData(assetRes.data),
+      scoutUpdate: unwrapData(updateRes.data)
+    }
+  };
+}
+function buildAssetBodyFromScout(scout, options) {
+  const body = {
+    name: options.assetName ?? scout.name ?? "Purchased scout",
+    scoutId: options.scoutId,
+    cost: options.cost ?? numericValue(scout.estimatedCost) ?? numericValue(scout.potentialCost) ?? 0,
+    acquisitionDate: options.acquisitionDate ?? Date.now()
+  };
+  for (const field of ["organizationId", "categoryId", "heroImage"]) {
+    if (typeof scout[field] === "string") body[field] = scout[field];
+  }
+  return body;
+}
+function numericValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function unwrapData(data) {
+  if (isRecord3(data) && "data" in data) return data.data;
+  return data;
+}
+function unwrapRecord(data) {
+  const unwrapped = unwrapData(data);
+  return isRecord3(unwrapped) ? unwrapped : null;
+}
+function fail(res) {
+  return {
+    ok: false,
+    status: res.status || 500,
+    error: res.error ?? "Request failed"
+  };
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/build-program.ts
+var _require = createRequire(import.meta.url);
+var { version: CLI_VERSION } = _require("../package.json");
+var rootOpts = {};
+function syncRootOptsFromCommand(cmd) {
+  const maybeCommand = cmd;
+  if (!maybeCommand || typeof maybeCommand !== "object") return;
+  if (typeof maybeCommand.opts !== "function") return;
+  let root = maybeCommand;
+  while (root.parent) root = root.parent;
+  if (typeof root.opts !== "function") return;
+  rootOpts = root.opts();
+}
+var DUMMY_HELPERS = {
+  getOutputFormat: () => "json",
+  requireToken: () => null,
+  exitWithError: () => {
+    throw new Error("Docs generator: action should not run");
+  },
+  getBaseUrl: () => "https://api.getpilfer.com",
+  syncRootOptsFromCommand: () => {
+  }
+};
+function addTopLevelCommands(program, helpers) {
+  const { getOutputFormat, requireToken, exitWithError } = helpers;
+  function getRequiredToken() {
+    const token = requireToken();
+    if (!token) exitWithError(401, "Missing or invalid token. Run: pilfer login");
+    return token;
+  }
+  function getOutputFormatFromProgram(_p) {
+    const raw = rootOpts.output;
+    if (raw === "json" || raw === "table" || raw === "csv") return raw;
+    return getDefaultOutputFormat();
+  }
+  function exitWithErrorHandler(program2, status, message) {
+    const format = getOutputFormatFromProgram(program2);
+    const payload = formatErrorPayload(status, message);
+    printStructuredError(format, payload);
+    process.exit(status === 401 || status === 403 ? 1 : 2);
+  }
+  program.action(() => {
+    console.log(`
+  Welcome to the Pilfer CLI - manage your Pilfer data from the terminal.
+
+  Get started
+  ----------
+  Log in:     pilfer login
+  Verify:     pilfer whoami
+  Overview:   pilfer status
+
+  Resources (list | get | create | update | delete)
+  ------------------------------------------------
+  organizations   projects   spaces   scouts
+  sources         assets     categories labels   views
+
+  Examples
+  --------
+  pilfer organizations list
+  pilfer projects create --name "Studio upgrade"
+  pilfer scouts list --status Shortlist
+  pilfer sources list --scout-id scout_123
+
+  Help
+  ----
+  pilfer --help
+  pilfer <resource> --help
+`);
+  });
+  program.command("resolve <resource>").description("Resolve one resource id by an exact field match").requiredOption("--name <value>", "Value to resolve").option("--field <field>", "Field to match", "name").option("--id-only", "Print only the resolved id").action(async (resource, opts) => {
+    const token = getRequiredToken();
+    const result = await resolveResourceByName({
+      resource,
+      field: opts.field,
+      name: opts.name,
+      token,
+      baseUrl: getBaseUrl(rootOpts.baseUrl ?? rootOpts.api),
+      request: apiRequest
+    });
+    if (!result.ok) {
+      const suffix = result.candidates && result.candidates.length > 0 ? ` Candidates: ${JSON.stringify(result.candidates)}` : "";
+      exitWithError(result.status, `${result.message}${suffix}`);
+      return;
+    }
+    if (opts.idOnly) {
+      const id = result.item._id ?? result.item.id;
+      if (typeof id !== "string") exitWithError(404, "Resolved item has no id");
+      console.log(id);
+      return;
+    }
+    printOutput(getOutputFormat(), result.item, false);
+  });
+  program.command("commands").description("Print machine-readable command metadata").option("--json", "Print JSON metadata").action(() => {
+    const payload = discoverCommands(program, CLI_VERSION);
+    console.log(JSON.stringify(payload));
+  });
+  program.command("schema").description("Print machine-readable resource schema").option("--json", "Print JSON schema").action(() => {
+    const payload = discoverCommands(program, CLI_VERSION);
+    console.log(JSON.stringify(buildResourceSchema(payload)));
+  });
+  program.command("whoami").description("Verify auth and show current user and token scopes").action(async () => {
+    const token = getRequiredToken();
+    const res = await apiRequest({
+      method: "GET",
+      path: "me",
+      token,
+      baseUrl: rootOpts.baseUrl
+    });
+    if (!res.ok) exitWithError(res.status || 401, res.error ?? "Unauthorized");
+    const data = res.data?.data ?? res.data;
+    printOutput(getOutputFormat(), data ?? {}, false);
+  });
+  program.command("login [token]").description("Store API token (prompt or pass token as argument)").action(async (tokenArg) => {
+    const { saveToken } = await import("./auth-VFGSMTC6.js");
+    let token = tokenArg?.trim();
+    if (!token) {
+      const readline = await import("readline");
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stderr
+      });
+      token = await new Promise((resolve) => {
+        rl.question("API token: ", (answer) => {
+          rl.close();
+          resolve(answer?.trim() ?? "");
+        });
+      });
+    }
+    if (!token) {
+      console.error("No token provided.");
+      process.exit(1);
+    }
+    const res = await apiRequest({
+      method: "GET",
+      path: "me",
+      token,
+      baseUrl: rootOpts.baseUrl
+    });
+    if (!res.ok) {
+      console.error("Invalid token or API error:", res.error ?? res.status);
+      process.exit(1);
+    }
+    saveToken(token);
+    console.log("Logged in successfully.");
+  });
+  const config = program.command("config").description("Persist and inspect CLI config");
+  config.command("show").description("Show stored CLI config").action(async () => {
+    const { getCredentialsPath, resolveStoredBaseUrl } = await import("./auth-VFGSMTC6.js");
+    const token = resolveToken(rootOpts.token ?? void 0);
+    const baseUrl = getBaseUrl(rootOpts.baseUrl ?? rootOpts.api);
+    const storedBaseUrl = resolveStoredBaseUrl();
+    printOutput(
+      getOutputFormat(),
+      {
+        configPath: getCredentialsPath(),
+        tokenConfigured: Boolean(token),
+        baseUrl,
+        baseUrlSource: rootOpts.baseUrl ?? rootOpts.api ? "flag" : process.env.PILFER_API_BASE_URL ? "env" : storedBaseUrl ? "config" : "default"
+      },
+      false
+    );
+  });
+  config.command("set-base-url <url>").alias("set-api").description("Persist default API base URL").action(async (url) => {
+    const { saveBaseUrl } = await import("./auth-VFGSMTC6.js");
+    const normalized = url.trim().replace(/\/$/, "");
+    if (!normalized) {
+      console.error("No base URL provided.");
+      process.exit(1);
+    }
+    saveBaseUrl(normalized);
+    console.log(`Saved API base URL: ${normalized}`);
+  });
+  config.command("unset-base-url").alias("unset-api").description("Remove persisted API base URL").action(async () => {
+    const { clearBaseUrl } = await import("./auth-VFGSMTC6.js");
+    clearBaseUrl();
+    console.log("Cleared stored API base URL.");
+  });
+  program.command("logout").description("Remove stored API token").action(async () => {
+    const { clearCredentials } = await import("./auth-VFGSMTC6.js");
+    clearCredentials();
+    console.log("Logged out.");
+  });
+  program.command("setup-agent").description("Print instructions for configuring Pilfer CLI for AI agents").action(() => {
+    console.log(`
+To use the Pilfer CLI from an AI agent or script:
+
+1. Set your API token:
+   export PILFER_API_TOKEN="plf_..."
+
+2. Optional: override API base URL for local or early deployments:
+   export PILFER_API_BASE_URL="https://api.getpilfer.com"
+
+3. Verify auth:
+   pilfer whoami
+
+4. Commands use the pattern: pilfer <resource> list|get|create|update|delete
+   When stdout is not a TTY, output defaults to JSON.
+`);
+  });
+  program.command("status").description("Situational summary: organizations, projects, spaces, scouts, assets").action(async () => {
+    const token = getRequiredToken();
+    const baseUrl = rootOpts.baseUrl;
+    const [orgsRes, projectsRes, spacesRes, scoutsRes, assetsRes] = await Promise.all([
+      apiRequest({
+        method: "GET",
+        path: "organizations",
+        token,
+        baseUrl
+      }),
+      apiRequest({
+        method: "GET",
+        path: "projects",
+        token,
+        baseUrl
+      }),
+      apiRequest({
+        method: "GET",
+        path: "spaces",
+        token,
+        baseUrl
+      }),
+      apiRequest({
+        method: "GET",
+        path: "scouts",
+        token,
+        baseUrl
+      }),
+      apiRequest({
+        method: "GET",
+        path: "assets",
+        token,
+        baseUrl
+      })
+    ]);
+    const unwrap = (res) => res.ok && res.data ? res.data.data ?? [] : [];
+    const scouts = unwrap(scoutsRes);
+    const scoutStatuses = scouts.reduce((acc, scout) => {
+      const status = scout.status ?? "unknown";
+      acc[status] = (acc[status] ?? 0) + 1;
+      return acc;
+    }, {});
+    printOutput(
+      getOutputFormat(),
+      {
+        organizations: unwrap(orgsRes).length,
+        projects: unwrap(projectsRes).length,
+        spaces: unwrap(spacesRes).length,
+        scouts: scouts.length,
+        assets: unwrap(assetsRes).length,
+        scoutsByStatus: scoutStatuses
+      },
+      false
+    );
+  });
+  program.exitOverride((err) => {
+    if (err.code === "commander.helpDisplayed" || err.code === "commander.version") {
+      throw err;
+    }
+    exitWithErrorHandler(program, 2, err.message);
+  });
+}
+async function registerGeneratedCommands(program, helpers) {
+  const mod = await import("./generated-7QDIZ5V5.js").catch(() => null);
+  if (mod?.register) mod.register(program, helpers);
+}
+function registerWorkflowCommands(program, helpers) {
+  const { getOutputFormat, requireToken, exitWithError, getBaseUrl: getBaseUrl2 } = helpers;
+  const scouts = program.commands.find((command) => command.name() === "scouts");
+  const reports = program.command("reports").description("Agent-oriented reports");
+  function getRequiredToken() {
+    const token = requireToken();
+    if (!token) exitWithError(401, "Missing or invalid token. Run: pilfer login");
+    return token;
+  }
+  registerRelationCommands(program, helpers, getRequiredToken);
+  reports.command("assets").description("Summarize asset value and category concentration").option("--project-id <id>", "Project scope").option("--space-id <id>", "Space scope").hook("preAction", (thisCommand) => {
+    helpers.syncRootOptsFromCommand(thisCommand);
+  }).action(async (opts) => {
+    const token = getRequiredToken();
+    const baseUrl = getBaseUrl2();
+    const assetsRes = await fetchList({
+      path: "assets",
+      token,
+      baseUrl,
+      query: {},
+      all: true,
+      request: apiRequest
+    });
+    if (!assetsRes.ok) {
+      exitWithError(assetsRes.status || 500, assetsRes.error ?? "Request failed");
+    }
+    printOutput(
+      getOutputFormat(),
+      buildAssetReport(assetsRes.data?.data ?? [], scopeFromOptions(opts)),
+      false
+    );
+  });
+  reports.command("balance").description("Compare owned asset value with active scouting pipeline").option("--project-id <id>", "Project scope").option("--space-id <id>", "Space scope").hook("preAction", (thisCommand) => {
+    helpers.syncRootOptsFromCommand(thisCommand);
+  }).action(async (opts) => {
+    const token = getRequiredToken();
+    const baseUrl = getBaseUrl2();
+    const [assetsRes, scoutsRes] = await Promise.all([
+      fetchList({
+        path: "assets",
+        token,
+        baseUrl,
+        query: {},
+        all: true,
+        request: apiRequest
+      }),
+      fetchList({
+        path: "scouts",
+        token,
+        baseUrl,
+        query: {},
+        all: true,
+        request: apiRequest
+      })
+    ]);
+    if (!assetsRes.ok) {
+      exitWithError(assetsRes.status || 500, assetsRes.error ?? "Request failed");
+    }
+    if (!scoutsRes.ok) {
+      exitWithError(scoutsRes.status || 500, scoutsRes.error ?? "Request failed");
+    }
+    printOutput(
+      getOutputFormat(),
+      buildBalanceReport(
+        assetsRes.data?.data ?? [],
+        scoutsRes.data?.data ?? [],
+        scopeFromOptions(opts)
+      ),
+      false
+    );
+  });
+  reports.command("scouting").description("Summarize scouting pipeline, shortlist pressure, and source gaps").option("--skip-sources", "Skip per-scout source checks").hook("preAction", (thisCommand) => {
+    helpers.syncRootOptsFromCommand(thisCommand);
+  }).action(async (opts) => {
+    const token = getRequiredToken();
+    const baseUrl = getBaseUrl2();
+    const scoutsRes = await fetchList({
+      path: "scouts",
+      token,
+      baseUrl,
+      query: {},
+      all: true,
+      request: apiRequest
+    });
+    if (!scoutsRes.ok) {
+      exitWithError(scoutsRes.status || 500, scoutsRes.error ?? "Request failed");
+    }
+    const scoutsData = scoutsRes.data?.data ?? [];
+    const sourcesByScout = opts.skipSources ? {} : await fetchSourcesByScout(scoutsData, token, baseUrl);
+    printOutput(
+      getOutputFormat(),
+      buildScoutingReport(scoutsData, sourcesByScout),
+      false
+    );
+  });
+  if (!scouts) return;
+  scouts.command("shortlist").description("Show shortlisted scouts in purchase priority order").option("--limit <n>", "Max rows").hook("preAction", (thisCommand) => {
+    helpers.syncRootOptsFromCommand(thisCommand);
+  }).action(async (opts) => {
+    const token = getRequiredToken();
+    const res = await fetchList({
+      path: "scouts",
+      token,
+      baseUrl: getBaseUrl2(),
+      query: {},
+      all: true,
+      request: apiRequest
+    });
+    if (!res.ok) exitWithError(res.status || 500, res.error ?? "Request failed");
+    const rows = buildShortlistRows(res.data?.data ?? []);
+    const limit = parseOptionalNumber(opts.limit, "--limit", exitWithError);
+    printOutput(
+      getOutputFormat(),
+      typeof limit === "number" ? rows.slice(0, limit) : rows,
+      false
+    );
+  });
+  scouts.command("pipeline").description("Summarize active scout pipeline by status").hook("preAction", (thisCommand) => {
+    helpers.syncRootOptsFromCommand(thisCommand);
+  }).action(async () => {
+    const token = getRequiredToken();
+    const res = await fetchList({
+      path: "scouts",
+      token,
+      baseUrl: getBaseUrl2(),
+      query: {},
+      all: true,
+      request: apiRequest
+    });
+    if (!res.ok) exitWithError(res.status || 500, res.error ?? "Request failed");
+    printOutput(getOutputFormat(), buildPipelineGroups(res.data?.data ?? []), false);
+  });
+  scouts.command("purchase <id>").description("Create an asset from a purchased scout and mark the scout Purchased").option("--name <value>", "Asset name override").option("--cost <value>", "Actual purchase cost").option("--acquisition-date <value>", "Acquisition timestamp in milliseconds").option("--dry-run", "Print proposed asset body without writing").hook("preAction", (thisCommand) => {
+    helpers.syncRootOptsFromCommand(thisCommand);
+  }).action(
+    async (id, opts) => {
+      const token = getRequiredToken();
+      const cost = parseOptionalNumber(opts.cost, "--cost", exitWithError);
+      const acquisitionDate = parseOptionalNumber(
+        opts.acquisitionDate,
+        "--acquisition-date",
+        exitWithError
+      );
+      const res = await purchaseScout({
+        scoutId: id,
+        token,
+        baseUrl: getBaseUrl2(),
+        assetName: opts.name,
+        cost,
+        acquisitionDate,
+        dryRun: Boolean(opts.dryRun),
+        request: apiRequest
+      });
+      if (!res.ok) {
+        exitWithError(res.status || 500, res.error ?? "Purchase workflow failed");
+      }
+      printOutput(getOutputFormat(), res.data ?? {}, false);
+    }
+  );
+}
+function registerRelationCommands(program, helpers, getRequiredToken) {
+  const { getOutputFormat, exitWithError, getBaseUrl: getBaseUrl2 } = helpers;
+  const configs = {
+    scouts: { relations: ["projects", "spaces", "labels"], relate: true },
+    assets: { relations: ["projects", "spaces", "labels"] },
+    projects: { relations: ["spaces", "scouts", "assets"] },
+    spaces: { relations: ["scouts", "assets"] }
+  };
+  const singularToPlural = {
+    project: "projects",
+    projects: "projects",
+    space: "spaces",
+    spaces: "spaces",
+    label: "labels",
+    labels: "labels",
+    scout: "scouts",
+    scouts: "scouts",
+    asset: "assets",
+    assets: "assets"
+  };
+  function relationFor(resource, raw) {
+    const relation = singularToPlural[raw];
+    if (!relation || !configs[resource]?.relations.includes(relation)) {
+      exitWithError(400, `Invalid relation for ${resource}: ${raw}`);
+    }
+    return relation;
+  }
+  function idsFromOption(raw) {
+    if (!raw) return [];
+    return [...new Set(raw.split(",").map((id) => id.trim()).filter(Boolean))];
+  }
+  for (const [resource, config] of Object.entries(configs)) {
+    const cmd = program.commands.find((command) => command.name() === resource);
+    if (!cmd) continue;
+    cmd.command("relations <id>").description(`List ${resource} relations`).hook("preAction", (thisCommand) => {
+      helpers.syncRootOptsFromCommand(thisCommand);
+    }).action(async (id) => {
+      const token = getRequiredToken();
+      const res = await apiRequest({
+        method: "GET",
+        path: `${resource}/${encodeURIComponent(id)}/relations`,
+        token,
+        baseUrl: getBaseUrl2()
+      });
+      if (!res.ok) exitWithError(res.status || 500, res.error ?? "Request failed");
+      printOutput(getOutputFormat(), res.data?.data ?? res.data ?? {}, false);
+    });
+    cmd.command("link <relation> <id> <targetId>").description(`Add a ${resource} relation`).hook("preAction", (thisCommand) => {
+      helpers.syncRootOptsFromCommand(thisCommand);
+    }).action(async (rawRelation, id, targetId) => {
+      const token = getRequiredToken();
+      const relation = relationFor(resource, rawRelation);
+      const res = await apiRequest({
+        method: "POST",
+        path: `${resource}/${encodeURIComponent(id)}/${relation}/${encodeURIComponent(targetId)}`,
+        token,
+        baseUrl: getBaseUrl2()
+      });
+      if (!res.ok) exitWithError(res.status || 500, res.error ?? "Request failed");
+      printOutput(getOutputFormat(), res.data?.data ?? res.data ?? {}, false);
+    });
+    cmd.command("unlink <relation> <id> <targetId>").description(`Remove a ${resource} relation`).hook("preAction", (thisCommand) => {
+      helpers.syncRootOptsFromCommand(thisCommand);
+    }).action(async (rawRelation, id, targetId) => {
+      const token = getRequiredToken();
+      const relation = relationFor(resource, rawRelation);
+      const res = await apiRequest({
+        method: "DELETE",
+        path: `${resource}/${encodeURIComponent(id)}/${relation}/${encodeURIComponent(targetId)}`,
+        token,
+        baseUrl: getBaseUrl2()
+      });
+      if (!res.ok) exitWithError(res.status || 500, res.error ?? "Request failed");
+      printOutput(getOutputFormat(), res.data?.data ?? res.data ?? {}, false);
+    });
+    for (const relation of config.relations) {
+      cmd.command(`set-${relation} <id>`).description(`Replace ${resource} ${relation} links`).requiredOption("--ids <ids>", "Comma-separated target ids").hook("preAction", (thisCommand) => {
+        helpers.syncRootOptsFromCommand(thisCommand);
+      }).action(async (id, opts) => {
+        const token = getRequiredToken();
+        const res = await apiRequest({
+          method: "PUT",
+          path: `${resource}/${encodeURIComponent(id)}/${relation}`,
+          token,
+          baseUrl: getBaseUrl2(),
+          body: { ids: idsFromOption(opts.ids) }
+        });
+        if (!res.ok) exitWithError(res.status || 500, res.error ?? "Request failed");
+        printOutput(getOutputFormat(), res.data?.data ?? res.data ?? {}, false);
+      });
+    }
+    if (resource === "scouts" && config.relate) {
+      cmd.command("relate <id> <relatedId>").description("Add a typed scout relationship").requiredOption("--type <type>", "parent_of|sub_scout_of|blocking|blocked_by|related_to|duplicate_of").hook("preAction", (thisCommand) => {
+        helpers.syncRootOptsFromCommand(thisCommand);
+      }).action(async (id, relatedId, opts) => {
+        const token = getRequiredToken();
+        const res = await apiRequest({
+          method: "POST",
+          path: `scouts/${encodeURIComponent(id)}/relationships`,
+          token,
+          baseUrl: getBaseUrl2(),
+          body: { relatedScoutId: relatedId, type: opts.type }
+        });
+        if (!res.ok) exitWithError(res.status || 500, res.error ?? "Request failed");
+        printOutput(getOutputFormat(), res.data?.data ?? res.data ?? {}, false);
+      });
+      cmd.command("unrelate <id> <linkId>").description("Remove a typed scout relationship by link id").hook("preAction", (thisCommand) => {
+        helpers.syncRootOptsFromCommand(thisCommand);
+      }).action(async (id, linkId) => {
+        const token = getRequiredToken();
+        const res = await apiRequest({
+          method: "DELETE",
+          path: `scouts/${encodeURIComponent(id)}/relationships/${encodeURIComponent(linkId)}`,
+          token,
+          baseUrl: getBaseUrl2()
+        });
+        if (!res.ok) exitWithError(res.status || 500, res.error ?? "Request failed");
+        printOutput(getOutputFormat(), res.data?.data ?? res.data ?? {}, false);
+      });
+    }
+  }
+}
+function scopeFromOptions(opts) {
+  return {
+    ...opts.projectId ? { projectId: opts.projectId } : {},
+    ...opts.spaceId ? { spaceId: opts.spaceId } : {}
+  };
+}
+async function fetchSourcesByScout(scouts, token, baseUrl) {
+  const rows = scouts.filter(isRecord4);
+  const entries = await Promise.all(
+    rows.map(async (scout) => {
+      const id = typeof scout._id === "string" ? scout._id : void 0;
+      if (!id) return null;
+      const res = await apiRequest({
+        method: "GET",
+        path: `scouts/${encodeURIComponent(id)}/sources`,
+        token,
+        baseUrl
+      });
+      return [id, res.ok ? res.data?.data ?? [] : []];
+    })
+  );
+  return Object.fromEntries(entries.filter((entry) => entry !== null));
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseOptionalNumber(value, flag, exitWithError) {
+  if (value == null || value === "") return void 0;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    exitWithError(400, `${flag} expected number, got ${JSON.stringify(value)}`);
+  }
+  return parsed;
+}
+function registerSourceCommands(program, helpers) {
+  const { getOutputFormat, requireToken, exitWithError, getBaseUrl: getBaseUrl2 } = helpers;
+  function getRequiredToken() {
+    const token = requireToken();
+    if (!token) exitWithError(401, "Missing or invalid token. Run: pilfer login");
+    return token;
+  }
+  const sources = program.command("sources").description("Manage scout sources");
+  sources.command("list").description("List sources for a scout").requiredOption("--scout-id <id>", "Scout id").option("--limit <n>", "Max results").option("--offset <n>", "Skip n results").option("--all", "Fetch all pages").option("--fields <fields>", "Comma-separated fields to print").option("--where <field=value>", "Client-side exact filters, comma-separated").option("--jsonl", "Print one compact JSON object per row").hook("preAction", (thisCommand) => {
+    helpers.syncRootOptsFromCommand(thisCommand);
+  }).action(async (opts) => {
+    const token = getRequiredToken();
+    const res = await fetchList({
+      path: `scouts/${encodeURIComponent(opts.scoutId)}/sources`,
+      token,
+      baseUrl: getBaseUrl2(),
+      query: { limit: opts.limit, offset: opts.offset },
+      all: Boolean(opts.all),
+      request: apiRequest
+    });
+    if (!res.ok) exitWithError(res.status || 500, res.error ?? "Request failed");
+    const data = res.data?.data ?? [];
+    printList({
+      format: getOutputFormat(),
+      data,
+      fields: opts.fields,
+      where: opts.where,
+      jsonl: Boolean(opts.jsonl)
+    });
+  });
+  sources.command("get <sourceId>").description("Get one source by id").requiredOption("--scout-id <id>", "Scout id").hook("preAction", (thisCommand) => {
+    helpers.syncRootOptsFromCommand(thisCommand);
+  }).action(async (sourceId, opts) => {
+    const token = getRequiredToken();
+    const res = await apiRequest({
+      method: "GET",
+      path: `scouts/${encodeURIComponent(opts.scoutId)}/sources/${encodeURIComponent(
+        sourceId
+      )}`,
+      token,
+      baseUrl: getBaseUrl2()
+    });
+    if (!res.ok) exitWithError(res.status || 500, res.error ?? "Request failed");
+    const data = res.data?.data ?? res.data;
+    printOutput(getOutputFormat(), data ?? {}, false);
+  });
+  sources.command("create").description("Create a source for a scout").requiredOption("--scout-id <id>", "Scout id").option("--url <value>", "url").option("--name <value>", "name").option("--title <value>", "deprecated alias for --name").option("--description <value>", "description").option("--price <value>", "price").option("--image <value>", "image").option("--image-url <value>", "deprecated alias for --image").option("--address <value>", "address").option("--source-type <value>", "sourceType").option("--condition <value>", "condition").option("--notes <value>", "notes").option("--starred <value>", "starred").option("--body <json>", "Request body JSON (merged with flags)").hook("preAction", (thisCommand) => {
+    helpers.syncRootOptsFromCommand(thisCommand);
+  }).action(async (opts) => {
+    const token = getRequiredToken();
+    const res = await apiRequest({
+      method: "POST",
+      path: `scouts/${encodeURIComponent(opts.scoutId)}/sources`,
+      token,
+      baseUrl: getBaseUrl2(),
+      body: sourceBodyFromFlags(opts, false, exitWithError)
+    });
+    if (!res.ok) exitWithError(res.status || 500, res.error ?? "Request failed");
+    const data = res.data?.data ?? res.data;
+    printOutput(getOutputFormat(), data ?? {}, false);
+  });
+  sources.command("update <sourceId>").description("Update a source").requiredOption("--scout-id <id>", "Scout id").option("--url <value>", "url").option("--name <value>", "name").option("--title <value>", "deprecated alias for --name").option("--description <value>", "description").option("--price <value>", "price").option("--image <value>", "image").option("--image-url <value>", "deprecated alias for --image").option("--address <value>", "address").option("--source-type <value>", "sourceType").option("--condition <value>", "condition").option("--notes <value>", "notes").option("--starred <value>", "starred").option("--body <json>", "Request body JSON (merged with flags)").hook("preAction", (thisCommand) => {
+    helpers.syncRootOptsFromCommand(thisCommand);
+  }).action(async (sourceId, opts) => {
+    const token = getRequiredToken();
+    const res = await apiRequest({
+      method: "PATCH",
+      path: `scouts/${encodeURIComponent(opts.scoutId)}/sources/${encodeURIComponent(
+        sourceId
+      )}`,
+      token,
+      baseUrl: getBaseUrl2(),
+      body: sourceBodyFromFlags(opts, true, exitWithError)
+    });
+    if (!res.ok) exitWithError(res.status || 500, res.error ?? "Request failed");
+    const data = res.data?.data ?? res.data;
+    printOutput(getOutputFormat(), data ?? {}, false);
+  });
+  sources.command("delete <sourceId>").description("Delete a source").requiredOption("--scout-id <id>", "Scout id").hook("preAction", (thisCommand) => {
+    helpers.syncRootOptsFromCommand(thisCommand);
+  }).action(async (sourceId, opts) => {
+    const token = getRequiredToken();
+    const res = await apiRequest({
+      method: "DELETE",
+      path: `scouts/${encodeURIComponent(opts.scoutId)}/sources/${encodeURIComponent(
+        sourceId
+      )}`,
+      token,
+      baseUrl: getBaseUrl2()
+    });
+    if (!res.ok) exitWithError(res.status || 500, res.error ?? "Request failed");
+    if (getOutputFormat() === "json") {
+      console.log(JSON.stringify({ data: null, deleted: true }));
+    }
+  });
+}
+async function createProgram(helpers) {
+  const program = new Command();
+  program.name("pilfer").description("Pilfer REST API CLI").version(CLI_VERSION).option("-t, --token <token>", "API token (overrides env and config file)").option("-o, --output <format>", "Output format: json | table | csv").option("--base-url <url>", "API base URL (default: https://api.getpilfer.com)").option("--api <url>", "Alias for --base-url").hook("preAction", (thisCommand) => {
+    syncRootOptsFromCommand(thisCommand);
+    const opts = thisCommand.opts();
+    if (opts.output == null || opts.output === "") {
+      thisCommand.setOptionValue("output", getDefaultOutputFormat());
+    }
+  });
+  const resolvedHelpers = helpers ?? DUMMY_HELPERS;
+  addTopLevelCommands(program, resolvedHelpers);
+  await registerGeneratedCommands(program, resolvedHelpers);
+  registerWorkflowCommands(program, resolvedHelpers);
+  registerSourceCommands(program, resolvedHelpers);
+  return program;
+}
+async function createProgramForCLI() {
+  const realHelpers = {
+    getOutputFormat: () => {
+      const raw = rootOpts.output;
+      if (raw === "json" || raw === "table" || raw === "csv") return raw;
+      return getDefaultOutputFormat();
+    },
+    requireToken: () => resolveToken(rootOpts.token ?? void 0),
+    exitWithError: (status, message) => {
+      const raw = rootOpts.output;
+      const format = raw === "json" || raw === "table" || raw === "csv" ? raw : getDefaultOutputFormat();
+      const payload = formatErrorPayload(status, message);
+      printStructuredError(format, payload);
+      process.exit(status === 401 || status === 403 ? 1 : 2);
+    },
+    getBaseUrl: () => getBaseUrl(rootOpts.baseUrl ?? rootOpts.api),
+    syncRootOptsFromCommand
+  };
+  return createProgram(realHelpers);
+}
+async function getProgramForDocs() {
+  return createProgram();
+}
+
+export {
+  syncRootOptsFromCommand,
+  createProgram,
+  createProgramForCLI,
+  getProgramForDocs
+};
+//# sourceMappingURL=chunk-NFFHTNJE.js.map