@elmundi/ship-cli 0.11.2 → 0.12.1

package/lib/commands/sync.mjs

@@ -7,7 +7,7 @@ import {
   writeState,
   findShipRoot,
 } from "../config/io.mjs";
-import { validateConfig } from "../config/schema.mjs";
+import { validateConfig, lanePatterns as lanePatternList } from "../config/schema.mjs";
 import { fetchManifest, fetchArtifact } from "../http.mjs";
 import {
   readCached,
@@ -26,6 +26,52 @@ import {
 } from "../state/lockfile.mjs";
 import { getCliVersion } from "../version.mjs";
 
+function printSyncHelp() {
+  console.log(`shipctl sync — fetch the catalog into .ship/cache (and optionally lock).
+
+WHAT THIS COMMAND DOES
+  Pulls the artifacts your repo declares — pins, the active preset,
+  per-agent rule collections, and any pattern referenced by your lanes
+  (Automations in the operator console) — from the methodology API
+  into .ship/cache/<kind>/<id>@<version>/. Verifies content_sha256,
+  writes meta, optionally produces a lockfile so 'shipctl run --offline'
+  is reproducible.
+
+USAGE
+  shipctl sync [--check-only] [--only <kind:id>]... [--channel <c>]
+               [--force-unpin] [--dry-run] [--lock] [--json] [--cwd <dir>]
+
+FLAGS
+  --check-only         Report what would change; do not write to disk.
+  --only <kind:id>     Restrict to one or more artifacts (repeatable).
+                       Example: --only pattern:role-developer --only collection:preset-web-app
+  --channel <c>        Override config.api.channel for this invocation
+                       (stable|edge).
+  --force-unpin        Ignore artifacts.pins[] and pull the manifest
+                       version. Use when intentionally bumping a pin.
+  --dry-run            Print the resolution plan; do not write or fetch.
+  --lock               After sync, materialise every pattern referenced
+                       by the declared lanes and write
+                       .ship/shipctl.lock.json (used by
+                       'shipctl run --offline').
+  --json               Emit a structured JSON summary on stdout.
+  --cwd <dir>          Repo root. Defaults to the current directory;
+                       searches upward for .ship/.
+  --help, -h           Show this help.
+
+EXAMPLES
+  shipctl sync                          # baseline pull
+  shipctl sync --check-only --json      # CI guard
+  shipctl sync --only pattern:role-developer --only tool:methodology-api
+  shipctl sync --lock                   # produce a reproducible lockfile
+
+EXIT CODE
+  0 when everything resolved.
+  20 when at least one artifact failed to fetch (or --lock left
+     unresolved entries).
+`);
+}
+
 function parseSyncArgs(rest) {
   const out = {
     cwd: process.cwd(),
@@ -36,10 +82,17 @@ function parseSyncArgs(rest) {
     only: [],
     lock: false,
     json: false,
+    help: false,
+    unknown: [],
   };
   const copy = [...rest];
   while (copy.length) {
     const a = copy[0];
+    if (a === "--help" || a === "-h") {
+      out.help = true;
+      copy.shift();
+      continue;
+    }
     if (a === "--check-only") {
       out.checkOnly = true;
       copy.shift();
@@ -95,6 +148,12 @@ function parseSyncArgs(rest) {
       copy.shift();
       continue;
     }
+    /* Previously we silently dropped unrecognised tokens here. That
+     * hid bashisms like a misspelt `--cheek-only`, so we now collect
+     * them and warn from `syncCommand` once parsing is complete.
+     * Stays non-fatal because existing CI scripts may rely on the old
+     * permissive behaviour. */
+    out.unknown.push(a);
     copy.shift();
   }
   return out;
@@ -457,19 +516,26 @@ export async function buildLockfile({ shipRoot, config, baseUrl, channel, verbos
   const notes = [];
 
   const pins = config.artifacts?.pins || {};
-  const lanePatterns = Object.entries(config.lanes || {})
-    .map(([laneId, lane]) => ({ laneId, lane }))
-    .filter((r) => r.lane && typeof r.lane.pattern === "string");
-  const pinPatterns = Object.keys(pins)
+  /* Flatten each lane into one (laneId, patternId) row per pattern so
+   * lanes that declare ``patterns: [a, b]`` (RFC-0008 C3.1) feed both
+   * into the sync/lockfile pipeline. Legacy ``pattern: <id>`` lanes
+   * normalise to a single-element list via lanePatternList(). */
+  const laneRows = [];
+  for (const [laneId, lane] of Object.entries(config.lanes || {})) {
+    for (const pid of lanePatternList(lane)) {
+      laneRows.push({ laneId, patternId: pid });
+    }
+  }
+  const pinRows = Object.keys(pins)
     .filter((k) => k.startsWith("pattern/"))
-    .map((k) => ({ laneId: null, lane: { pattern: k.slice("pattern/".length) } }));
+    .map((k) => ({ laneId: null, patternId: k.slice("pattern/".length) }));
 
   /* De-duplicate on pattern id while preserving lane provenance (useful
    * for the `notes` field — operators want to know which lane pinned a
    * given pattern when they read the diff). */
   const seen = new Map();
-  for (const row of [...lanePatterns, ...pinPatterns]) {
-    const pid = row.lane.pattern;
+  for (const row of [...laneRows, ...pinRows]) {
+    const pid = row.patternId;
     if (!seen.has(pid)) seen.set(pid, { id: pid, by: [] });
     seen.get(pid).by.push(row.laneId || "config.artifacts.pins");
   }
@@ -637,8 +703,17 @@ function cmpSemver(a, b) {
 
 export async function syncCommand(ctx, rest) {
   const args = parseSyncArgs(rest);
+  if (args.help) {
+    printSyncHelp();
+    return;
+  }
   if (ctx?.dryRun) args.dryRun = true;
   if (ctx?.json) args.json = true;
+  for (const tok of args.unknown) {
+    console.warn(
+      `warn: shipctl sync: ignoring unknown argument '${tok}'. Run 'shipctl sync --help'.`,
+    );
+  }
 
   let result;
   try {

package/lib/commands/trigger.mjs

@@ -0,0 +1,200 @@
+import { readConfig } from "../config/io.mjs";
+
+const VERSION = "v1";
+
+export async function triggerCommand(ctx, rest) {
+  const opts = parseArgs(rest);
+  const baseUrl = resolveBaseUrl(opts.baseUrl || explicitGlobalBaseUrl(ctx));
+  const token = requireToken();
+  let workspaceId = opts.workspace;
+  if (!workspaceId) workspaceId = await resolveSoleWorkspace(baseUrl, token);
+  const repoId = await resolveRepoId(baseUrl, token, workspaceId, opts.repo);
+  const { config } = readConfig(opts.cwd || process.cwd());
+
+  const result = await apiPostJson(
+    baseUrl,
+    `/v1/workspaces/${encodeURIComponent(workspaceId)}/repos/${encodeURIComponent(repoId)}/trigger`,
+    {
+      event: opts.event,
+      config,
+      github: {
+        event_name: process.env.SHIP_EVENT_NAME || process.env.GITHUB_EVENT_NAME || "",
+        ref: process.env.SHIP_REF || process.env.GITHUB_REF || "",
+        sha: process.env.SHIP_SHA || process.env.GITHUB_SHA || "",
+        run_id: process.env.GITHUB_RUN_ID || "",
+      },
+    },
+    token,
+  );
+
+  if (ctx.json || opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  const due = Array.isArray(result.due_lanes) ? result.due_lanes : [];
+  if (!due.length) {
+    console.log(`Ship trigger ${opts.event}: no lanes due.`);
+    return;
+  }
+  console.log(`Ship trigger ${opts.event}: ${due.length} lane(s) due`);
+  for (const lane of due) console.log(`  - ${lane.lane_id}`);
+}
+
+function explicitGlobalBaseUrl(ctx) {
+  return ctx?.baseUrlSource === "flag" ? ctx.baseUrl : null;
+}
+
+function printHelp() {
+  console.log(`shipctl trigger — ask Ship which lanes are due (${VERSION})
+
+USAGE
+  shipctl trigger --event schedule --repo <id|owner/name> [--workspace <id>] [--json]
+
+ENV
+  SHIP_API_TOKEN             Required.
+  SHIP_WORKSPACE_API_BASE    Optional API base override.
+  SHIP_API_BASE              Fallback API base override.
+`);
+}
+
+function parseArgs(args) {
+  const out = {
+    event: null,
+    workspace: null,
+    repo: null,
+    baseUrl: null,
+    cwd: null,
+    json: false,
+  };
+  const copy = [...args];
+  const consume = (flag, key) => {
+    if (copy[0] === flag && copy[1] !== undefined) {
+      copy.shift();
+      out[key] = String(copy.shift());
+      return true;
+    }
+    const p = `${flag}=`;
+    if (copy[0] && copy[0].startsWith(p)) {
+      out[key] = copy[0].slice(p.length);
+      copy.shift();
+      return true;
+    }
+    return false;
+  };
+  while (copy.length) {
+    if (
+      consume("--event", "event") ||
+      consume("--workspace", "workspace") ||
+      consume("--repo", "repo") ||
+      consume("--base-url", "baseUrl") ||
+      consume("--cwd", "cwd")
+    ) {
+      continue;
+    }
+    if (copy[0] === "--json") {
+      out.json = true;
+      copy.shift();
+      continue;
+    }
+    if (copy[0] === "--help" || copy[0] === "-h") {
+      printHelp();
+      process.exit(0);
+    }
+    console.error(`Unknown flag: ${copy[0]}`);
+    process.exit(1);
+  }
+  if (!out.event) {
+    console.error("Usage: shipctl trigger --event <schedule> --repo <id|owner/name>");
+    process.exit(1);
+  }
+  if (!["schedule", "manual", "pull_request", "push"].includes(out.event)) {
+    console.error("--event must be one of: schedule, manual, pull_request, push");
+    process.exit(1);
+  }
+  return out;
+}
+
+function requireToken() {
+  const token = process.env.SHIP_API_TOKEN || "";
+  if (!token) {
+    console.error("SHIP_API_TOKEN is required.");
+    process.exit(1);
+  }
+  return token;
+}
+
+function resolveBaseUrl(explicit) {
+  if (explicit) return explicit.replace(/\/+$/, "");
+  if (process.env.SHIP_WORKSPACE_API_BASE) return process.env.SHIP_WORKSPACE_API_BASE.replace(/\/+$/, "");
+  if (process.env.SHIP_API_BASE) return process.env.SHIP_API_BASE.replace(/\/+$/, "");
+  return "https://api.ship.elmundi.com";
+}
+
+async function resolveSoleWorkspace(baseUrl, token) {
+  const rows = await apiGetJson(baseUrl, "/v1/workspaces", token);
+  if (!Array.isArray(rows) || rows.length === 0) {
+    console.error("No workspaces visible to this token.");
+    process.exit(1);
+  }
+  if (rows.length > 1) {
+    console.error("Token has access to more than one workspace; pass --workspace <id>.");
+    process.exit(1);
+  }
+  return String(rows[0].id);
+}
+
+async function resolveRepoId(baseUrl, token, workspaceId, hint) {
+  if (hint && /^[0-9a-fA-F-]{32,36}$/.test(hint) && hint.includes("-")) return hint;
+  const rows = await apiGetJson(baseUrl, `/v1/workspaces/${encodeURIComponent(workspaceId)}/repos`, token);
+  if (!Array.isArray(rows) || rows.length === 0) {
+    console.error(`Workspace ${workspaceId} has no activated repos.`);
+    process.exit(1);
+  }
+  if (hint) {
+    const match = rows.find((r) => r.full_name === hint || `${r.owner ?? ""}/${r.name ?? ""}` === hint || r.id === hint);
+    if (!match) {
+      console.error(`--repo ${hint} doesn't match any activated repo in workspace ${workspaceId}.`);
+      process.exit(1);
+    }
+    return String(match.id);
+  }
+  return String(rows[0].id);
+}
+
+async function apiGetJson(baseUrl, path, token) {
+  return apiRequest(baseUrl, path, "GET", token, null);
+}
+
+async function apiPostJson(baseUrl, path, body, token) {
+  return apiRequest(baseUrl, path, "POST", token, body);
+}
+
+async function apiRequest(baseUrl, path, method, token, body) {
+  const url = `${baseUrl}${path}`;
+  let res;
+  try {
+    res = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        Authorization: `Bearer ${token}`,
+      },
+      body: body === null ? undefined : JSON.stringify(body),
+    });
+  } catch (err) {
+    console.error(`Network error calling ${url}: ${err instanceof Error ? err.message : err}`);
+    process.exit(3);
+  }
+  const text = await res.text();
+  let data = null;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+    data = text;
+  }
+  if (res.ok) return data;
+  const msg = typeof data === "string" ? data : JSON.stringify(data);
+  console.error(`HTTP ${res.status} ${res.statusText} on ${method} ${url}\n${msg}`);
+  process.exit(res.status >= 500 ? 3 : 1);
+}

package/lib/config/migrate.mjs

@@ -19,7 +19,11 @@
  * the input untouched.
  */
 
-import { CONFIG_SCHEMA_VERSION, LEGACY_CONFIG_SCHEMA_VERSION } from "./schema.mjs";
+import {
+  CONFIG_SCHEMA_VERSION,
+  DEFAULT_PROCESS_CONFIG,
+  LEGACY_CONFIG_SCHEMA_VERSION,
+} from "./schema.mjs";
 
 /**
  * Default lane translations for the well-known v1 `lanes:` list entries.
@@ -34,23 +38,23 @@ import { CONFIG_SCHEMA_VERSION, LEGACY_CONFIG_SCHEMA_VERSION } from "./schema.mj
 const V1_LANE_DEFAULTS = Object.freeze({
   pr_review: {
     kind: "event",
-    pattern: "catalog-a5-pr-self-review",
+    pattern: "flow-pr-self-review",
     on: "pull_request",
     permissions: { contents: "read", "pull-requests": "write" },
   },
   daily_standup: {
     kind: "schedule",
-    pattern: "catalog-a13-daily-retro",
+    pattern: "flow-daily-retro",
     cron: "0 9 * * 1-5",
   },
   tech_debt: {
     kind: "schedule",
-    pattern: "catalog-a12-learning",
+    pattern: "flow-learning-capture",
     cron: "0 10 * * 1",
   },
   self_heal: {
     kind: "event",
-    pattern: "cloud-workflow-self-heal",
+    pattern: "op-workflow-self-heal",
     on: "workflow_run",
     when: { conclusion: "failure" },
     permissions: { contents: "read", actions: "read", "pull-requests": "write" },
@@ -132,6 +136,10 @@ export function migrateV1ToV2(input) {
     out.agent.default.provider = liftedProvider;
   }
 
+  if (!out.process || typeof out.process !== "object" || Array.isArray(out.process)) {
+    out.process = cloneDefault(DEFAULT_PROCESS_CONFIG());
+  }
+
   /* lanes: translate from the legacy list-of-strings shape. */
   out.lanes = {};
   const srcLanes = src.lanes;