tines 0.0.136 → 0.0.138

package/dist/index.js

@@ -3828,6 +3828,7 @@ function createApiClient(options) {
     // Projects
     listProjects: (params = {}) => get(`/api/v1/projects${query(params)}`),
     createProject: (body) => request("POST", "/api/v1/projects", body),
+    listStarters: () => get("/api/v1/projects/starters"),
     getProject: (id) => get(`/api/v1/projects/${id}`),
     updateProject: (id, body) => request("PATCH", `/api/v1/projects/${id}`, body),
     deleteProject: (id, body) => request("DELETE", `/api/v1/projects/${id}`, body),
@@ -4465,7 +4466,9 @@ async function resolveProject(api, ref) {
   die(`no project named "${ref}" (have: ${have || "none"})`);
 }
 async function resolveWorkflow(api, ref) {
-  const { items } = await api.listWorkflows();
+  return pickWorkflow((await api.listWorkflows()).items, ref);
+}
+function pickWorkflow(items, ref) {
   const found = items.find((w) => w.id === ref) ?? (items.filter((w) => w.name === ref).length === 1 ? items.find((w) => w.name === ref) : void 0);
   if (found) return found;
   if (items.filter((w) => w.name === ref).length > 1) {
@@ -7970,6 +7973,20 @@ existing sets wholesale when present.
 Each NEW state should carry a "prompt" \u2014 its initial stage instructions,
 created as a state-scoped context item \u2014 or pass --no-prompts to skip.
 
+A state may inherit context from another state \u2014 its base \u2014 with
+"inherits_from". Give the base as "<workflow>/<state>" (the qualified form
+\`tines workflows show\` prints, so it can be pasted straight back in), as a
+bare state name to mean one of this same request's states, or as a state id:
+
+  { "id": "wfs_abc", "name": "Merging", "category": "active",
+    "inherits_from": "Engineering/Review" }
+
+Items scoped to the base are part of an issue's context in the child state,
+stitched before the child's own layer. Chains are at most 3 states long and
+may not cycle. On an EXISTING state (one with an "id") the field is
+merge-patch: leaving it out keeps the current base, and "inherits_from": null
+clears it. See \`tines workflows bases\` for the pointers already in place.
+
 A transition may declare artifact requirements ("requires"): it can then only
 be taken once a FRESH artifact with that name \u2014 attached (or reaffirmed)
 since the issue entered its current state \u2014 exists on the issue:
@@ -7983,18 +8000,92 @@ since the issue entered its current state \u2014 exists on the issue:
 "image/"; file/text only) are optional narrowing; "artifact" is the slot
 name issues must carry (see: tines issues artifacts --help).
 `;
-function printWorkflowDetail(wf) {
+async function loadLibrary(api) {
+  const workflows = await listAll((page) => api.listWorkflows(page));
+  const states = /* @__PURE__ */ new Map();
+  for (const workflow of workflows) {
+    for (const state of workflow.states) states.set(state.id, { workflow, state });
+  }
+  const children = /* @__PURE__ */ new Map();
+  for (const entry of states.values()) {
+    const base = entry.state.inherits_from;
+    if (base === null) continue;
+    const siblings = children.get(base);
+    if (siblings) siblings.push(entry);
+    else children.set(base, [entry]);
+  }
+  return { workflows, states, children };
+}
+var qualify = (entry) => `${entry.workflow.name} / ${entry.state.name}`;
+function stateLabel(lib, id) {
+  const entry = lib.states.get(id);
+  return entry ? qualify(entry) : id;
+}
+function inheritanceLines(lib, state) {
+  const lines = [];
+  if (state.inherits_from !== null) {
+    lines.push(`    inherits from: ${stateLabel(lib, state.inherits_from)}`);
+  }
+  const kids = lib.children.get(state.id) ?? [];
+  if (kids.length > 0) lines.push(`    inherited by: ${kids.map(qualify).join(", ")}`);
+  return lines;
+}
+async function resolveStateBases(states, library) {
+  if (!Array.isArray(states)) return;
+  let lib;
+  for (const entry of states) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const state = entry;
+    if (typeof state.inherits_from !== "string" || !state.inherits_from.includes("/")) continue;
+    lib ??= await library();
+    state.inherits_from = resolveBasePair(
+      lib,
+      state.inherits_from,
+      typeof state.name === "string" ? state.name : "(unnamed)"
+    );
+  }
+}
+function resolveBasePair(lib, pair, stateName) {
+  const sep2 = pair.indexOf("/");
+  const workflowRef = pair.slice(0, sep2).trim();
+  const stateRef = pair.slice(sep2 + 1).trim();
+  const where = `state "${stateName}" inherits from "${pair}"`;
+  if (!workflowRef || !stateRef) {
+    die(`${where}, which is not a <workflow>/<state> pair`);
+  }
+  const byName = lib.workflows.filter((w) => w.name === workflowRef);
+  if (byName.length > 1)
+    die(`${where}, but workflow name "${workflowRef}" is ambiguous; use an id`);
+  const workflow = lib.workflows.find((w) => w.id === workflowRef) ?? byName[0];
+  if (!workflow) {
+    die(
+      `${where}, but there is no workflow "${workflowRef}" (have: ${lib.workflows.map((w) => w.name).join(", ")})`
+    );
+  }
+  const state = workflow.states.find((s) => s.name === stateRef) ?? workflow.states.find((s) => s.id === stateRef);
+  if (!state) {
+    die(
+      `${where}, but workflow "${workflow.name}" has no state "${stateRef}" (have: ${workflow.states.map((s) => s.name).join(", ")})`
+    );
+  }
+  return state.id;
+}
+function printWorkflowDetail(wf, lib) {
   console.log(`${wf.name}${wf.is_system ? " (standard, read-only)" : ""}  [${wf.id}]`);
   if (wf.description) console.log(wf.description);
   console.log("\nstates:");
   const byId = new Map(wf.states.map((s) => [s.id, s]));
-  table(
+  const rows = wf.states.length === 0 ? [] : formatTable(
     wf.states.map((s) => [
       `  ${s.name}`,
       s.category,
       s.id === wf.initial_state_id ? "(initial)" : ""
     ])
-  );
+  ).split("\n");
+  for (const [i, row] of rows.entries()) {
+    console.log(row);
+    for (const line of inheritanceLines(lib, wf.states[i])) console.log(line);
+  }
   console.log("\ntransitions:");
   for (const t of wf.transitions) {
     console.log(
@@ -8034,10 +8125,38 @@ function register11(program3) {
   withCommon(
     workflows.command("show <id-or-name>").description("Show a workflow with states and transitions")
   ).action(async (ref, opts) => {
-    const api = client(opts);
-    const wf = await resolveWorkflow(api, ref);
+    const lib = await loadLibrary(client(opts));
+    const wf = pickWorkflow(lib.workflows, ref);
     if (opts.json) return printJson(wf);
-    printWorkflowDetail(wf);
+    printWorkflowDetail(wf, lib);
+  });
+  withCommon(
+    workflows.command("bases").description("List the states other states inherit context from, with their children")
+  ).action(async (opts) => {
+    const lib = await loadLibrary(client(opts));
+    const bases = [...lib.states.values()].filter((e) => lib.children.has(e.state.id));
+    if (opts.json) {
+      const ref = (e) => ({
+        workflow: { id: e.workflow.id, name: e.workflow.name },
+        state: { id: e.state.id, name: e.state.name }
+      });
+      return printJson(
+        bases.map((b) => ({
+          ...ref(b),
+          inherited_by: lib.children.get(b.state.id).map(ref)
+        }))
+      );
+    }
+    if (bases.length === 0) return console.log("no base states");
+    let group;
+    for (const base of bases) {
+      if (base.workflow.id !== group) {
+        console.log(`${group === void 0 ? "" : "\n"}${base.workflow.name}`);
+        group = base.workflow.id;
+      }
+      console.log(`  ${base.state.name}`);
+      console.log(`    inherited by: ${lib.children.get(base.state.id).map(qualify).join(", ")}`);
+    }
   });
   withCommon(
     workflows.command("create [json]").description(
@@ -8053,11 +8172,13 @@ see \`tines workflows create --help\` for the expected shape`
         );
       }
       assertNewStatesHavePrompts(body.states, opts.prompts);
-      const wf = await client(opts).createWorkflow(body);
+      const api = client(opts);
+      await resolveStateBases(body.states, () => loadLibrary(api));
+      const wf = await api.createWorkflow(body);
       if (opts.json) return printJson(wf);
       console.log(`created workflow "${wf.name}" (${wf.id})
 `);
-      printWorkflowDetail(wf);
+      printWorkflowDetail(wf, await loadLibrary(api));
     }
   );
   withCommon(
@@ -8065,9 +8186,11 @@ see \`tines workflows create --help\` for the expected shape`
   ).action(
     async (ref, inline, opts) => {
       const api = client(opts);
-      const wf = await resolveWorkflow(api, ref);
+      const lib = await loadLibrary(api);
+      const wf = pickWorkflow(lib.workflows, ref);
       const body = readJsonBody(inline, opts.file) ?? {};
       assertNewStatesHavePrompts(body.states, opts.prompts);
+      await resolveStateBases(body.states, async () => lib);
       if (opts.name !== void 0) body.name = opts.name;
       if (opts.description !== void 0) body.description = opts.description;
       if (opts.initialState !== void 0) body.initial_state = opts.initialState;
@@ -8078,7 +8201,7 @@ see \`tines workflows create --help\` for the expected shape`
       if (opts.json) return printJson(updated);
       console.log(`updated workflow "${updated.name}" (${updated.id})
 `);
-      printWorkflowDetail(updated);
+      printWorkflowDetail(updated, await loadLibrary(api));
     }
   );
   withCommon(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tines",
-  "version": "0.0.136",
+  "version": "0.0.138",
   "description": "CLI for Tines, an orchestration layer for AI agents",
   "repository": {
     "type": "git",